diff --git a/app/assets/javascripts/setting_format.js b/app/assets/javascripts/setting_format.js
deleted file mode 100644
index ae5cbcc..0000000
--- a/app/assets/javascripts/setting_format.js
+++ /dev/null
@@ -1,15 +0,0 @@
-(function(){
-  "use strict";
-
-  $(function(){
-    var $select = $('#setting-format select');
-    if($select.length === 0) return;
-
-    var $options = $('#setting-format-options');
-    console.log($options);
-    debugger;
-    $select.on("change", function(ev){
-    });
-  });
-})();
-
diff --git a/app/assets/javascripts/vue/fluent_log.js b/app/assets/javascripts/vue/fluent_log.js
index 2cab738..016ab86 100644
--- a/app/assets/javascripts/vue/fluent_log.js
+++ b/app/assets/javascripts/vue/fluent_log.js
@@ -14,10 +14,7 @@
         "processing": false
       },
 
-      created: function(){
-        if(this.initialAutoReload) {
-          this.autoFetch = true;
-        }
+      compiled: function(){
         this.fetchLogs();
 
         var self = this;
@@ -33,6 +30,9 @@
             clearInterval(timer);
           }
         });
+        if(this.initialAutoReload) {
+          this.autoFetch = true;
+        }
       },
 
       computed: {
diff --git a/app/assets/javascripts/vue/in_tail_format.js b/app/assets/javascripts/vue/in_tail_format.js
index 3b2489e..d7bb0e5 100644
--- a/app/assets/javascripts/vue/in_tail_format.js
+++ b/app/assets/javascripts/vue/in_tail_format.js
@@ -4,45 +4,58 @@
   $(function(){
     if($('#in_tail_format').length === 0) return;
 
+    var FormatBundle = Vue.component('format-bundle', {
+      inherit: true,
+      template: "#format-bundle",
+      computed: {
+        options: {
+          get: function(){
+            return _.contains(this.selectableFormats, this.format) && this.formatOptions[this.format];
+          },
+        },
+        selectableFormats: {
+          get: function() {
+            if(!this.formatOptions) return [""];
+            var formats = Object.keys(this.formatOptions);
+            return formats;
+          }
+        }
+      }
+    });
+
     new Vue({
       el: "#in_tail_format",
-      paramAttributes: ["formatOptions", "initialSelected", "targetFile", "paramsJson"],
+      paramAttributes: ["formatOptionsJson", "initialSelected", "targetFile", "paramsJson"],
       data: {
-        regexp: "",
-        grok_str: "",
-        time_format: "",
         previewProcessing: false,
-        highlightedLines: null
+        format: "",
+        highlightedLines: null,
       },
 
-      created: function(){
-        this.formatOptions = JSON.parse(this.formatOptions);
-        this.formats = Object.keys(this.formatOptions);
+      compiled: function(){
+        this.$watch('params.setting.regexp', function(){
+          this.preview();
+        });
+        this.$watch('format', function(){
+          this.preview();
+        });
+        this.$set("formatOptions", JSON.parse(this.formatOptionsJson));
         this.format = this.initialSelected;
-        this.params = JSON.parse(this.paramsJson);
-        if(this.params && this.params.setting) {
-          this.grok_str = this.params.setting.grok_str;
-          this.regexp = this.params.setting.regexp;
+
+        // initialize params
+        // NOTE: if `params.setting.foo` is undefined, Vue can't binding with v-model="params.setting.foo"
+        var params = JSON.parse(this.paramsJson);
+        if(!params.setting) {
+          params.setting = {};
         }
-        this.$watch('regexp', function(ev){
-          this.preview();
+        _.each(this.formatOptions, function(options){
+          _.each(options, function(key){
+            if(!params.setting.hasOwnProperty(key)){
+              params.setting[key] = "";
+            }
+          });
         });
-        this.$watch('format', function(ev){
-          this.preview();
-        });
-
-        var updateGrokPreview = _.debounce(_.bind(this.generateRegexp, this), 256);
-        this.$watch('grok_str', updateGrokPreview);
-      },
-
-      computed: {
-        options: function(){
-          return this.formatOptions[this.format];
-        },
-
-        selectableFormats: function() {
-          return _.filter(this.formats, function(format){ return format !== "regexp"; });
-        }
+        this.$set('params', params);
       },
 
       methods: {
@@ -114,38 +127,20 @@
               method: "POST",
               url: "/api/regexp_preview",
               data: {
-                regexp: self.regexp,
-                format: self.formatType == "regexp" ? "regexp" : self.format,
-                time_format: self.time_format,
+                regexp: self.params.setting.regexp,
+                time_format: self.params.setting.time_format,
+                format: _.isEmpty(self.format) ? "regexp" : self.format,
                 file: self.targetFile
               }
             }).done(resolve).fail(reject);
           }).then(function(result){
-            self.time_format = result.time_format;
+            self.params = _.merge(self.params, result.params);
             self.regexpMatches = result.matches;
             self.updateHighlightedLines();
           })["catch"](function(error){
             console.error(error.stack);
           });
         },
-
-        generateRegexp: function() {
-          // for grok
-          var self = this;
-          new Promise(function(resolve, reject) {
-            $.ajax({
-              method: "POST",
-              url: "/api/grok_to_regexp",
-              data: {
-                grok_str: self.grok_str
-              }
-            }).done(resolve).fail(reject);
-          }).then(function(regexp){
-            self.regexp = regexp;
-          }).catch(function(e){
-            console.error(e);
-          });
-        },
       }
     });
   });
diff --git a/app/assets/javascripts/notification.js b/app/assets/javascripts/vue/notification.js
similarity index 93%
rename from app/assets/javascripts/notification.js
rename to app/assets/javascripts/vue/notification.js
index 587066f..04aa6ae 100644
--- a/app/assets/javascripts/notification.js
+++ b/app/assets/javascripts/vue/notification.js
@@ -46,10 +46,10 @@
 
       computed: {
         alertsCount: {
-          $get: function(){ return this.alerts.length; }
+          get: function(){ return this.alerts.length; }
         },
         hasAlerts: {
-          $get: function(){ return this.alertsCount > 0; }
+          get: function(){ return this.alertsCount > 0; }
         }
       },
 
diff --git a/app/assets/javascripts/vue/settings.js b/app/assets/javascripts/vue/settings.js
index 6148e88..64f685a 100644
--- a/app/assets/javascripts/vue/settings.js
+++ b/app/assets/javascripts/vue/settings.js
@@ -7,24 +7,29 @@
 
     new Vue({
       el: el,
-      data: {
-        loaded: false,
-        loading: false,
-        sections: {
-          sources: [],
-          matches: []
-        }
+      data: function(){
+        return {
+          loaded: false,
+          loading: false,
+          sections: {
+            sources: [],
+            matches: []
+          }
+        };
       },
-      created: function() {
+      ready: function() {
         this.update();
       },
       components: {
         section: {
+          inherit: true,
           template: "#vue-setting-section",
-          data: {
-            mode: "default",
-            processing: false,
-            editContent: null
+          data: function(){
+            return {
+              mode: "default",
+              processing: false,
+              editContent: null
+            };
           },
           created: function(){
             this.initialState();
@@ -57,16 +62,20 @@
                   content: this.editContent
                 }
               }).then(function(data){
-                // NOTE: child VM update doesn't effect to parent VM (at least Vue v0.10)
-                self.$data = data;
+                // NOTE: self.$data = data doesn't work as well, so using _.each
+                //       whole $data swapping breaks mode switching..
+                _.each(data, function(v,k){
+                  self[k] = v;
+                });
                 self.initialState();
               }).always(function(){
                 self.processing = false;
               });
             },
             initialState: function(){
-              this.mode = "default";
-              this.editContent = this.content;
+              this.$set('processing', false);
+              this.$set('mode', 'default');
+              this.$set('editContent', this.content);
             },
             destroy: function(){
               var self = this;
diff --git a/app/assets/javascripts/vue/treeview.js b/app/assets/javascripts/vue/treeview.js
index 0b8f9f9..51fc929 100644
--- a/app/assets/javascripts/vue/treeview.js
+++ b/app/assets/javascripts/vue/treeview.js
@@ -9,11 +9,12 @@
       paramAttributes: [],
       data: {
         preview: "",
+        path: "",
         initialPath: "/var/log",
         paths: []
       },
 
-      created: function(){
+      compiled: function(){
         this.path = this.initialPath;
         this.fetchTree();
         this.$watch("path", this.fetchTree);
diff --git a/app/controllers/api_controller.rb b/app/controllers/api_controller.rb
index f8d2f55..998b784 100644
--- a/app/controllers/api_controller.rb
+++ b/app/controllers/api_controller.rb
@@ -22,8 +22,12 @@ class ApiController < ApplicationController
     preview = RegexpPreview.new(params[:file], params[:format], regexp: params[:regexp], time_format: params[:time_format])
     matches = preview.matches
     render json: {
-      regexp: preview.regexp.try(:source),
-      time_format: preview.time_format,
+      params: {
+        setting: {
+          regexp: preview.regexp.try(:source),
+          time_format: preview.time_format,
+        }
+      },
       matches: matches.compact,
     }
   end
diff --git a/app/views/shared/vue/_in_tail_format.html.erb b/app/views/shared/vue/_in_tail_format.html.erb
index d784e6c..7b6b66c 100644
--- a/app/views/shared/vue/_in_tail_format.html.erb
+++ b/app/views/shared/vue/_in_tail_format.html.erb
@@ -1,19 +1,4 @@
-<div id="in_tail_format" class="form-group"
-  formatOptions="<%= formats.to_json %>"
-  initialSelected="<%= initialSelected %>"
-  targetFile="<%= file %>"
-  paramsJson="<%= params.to_json %>"
-  >
-  <div class="form-group">
-    <label>
-      <input type="radio" v-model="formatType" value="bundled">bundled
-    </label>
-    <label>
-      <input type="radio" v-model="formatType" value="regexp">regexp
-    </label>
-  </div>
-
-  <div v-if="formatType == 'bundled'">
+<script type="text/template" id="format-bundle">
     <div class="form-group">
       <label>format</label>
       <select name="setting[format]" v-model="format">
@@ -22,28 +7,18 @@
     </div>
     <div class="form-group" v-repeat="options">
       <label>{{ $value }} </label>
-      <input type="text" name="setting[{{ $value }}]" v-model="{{ $value }}" size="100%" />
-      <span v-if="format == 'grok' && previewProcessing"><%= icon('fa-spin fa-refresh fa-lg') %></span>
+      <input type="text" name="setting[{{ $value }}]" v-model="params.setting[$value]" size="100%" />
     </div>
-    <div v-if="format == 'grok'">
-      <pre v-if="highlightedLines">{{{ highlightedLines }}}</pre>
-      <div class="well well-sm">
-        <%= raw t('fluentd.settings.grok_manual') %>
-      </div>
-    </div>
-  </div>
+</script>
 
-  <div v-if="formatType == 'regexp'">
-    <div class="form-group">
-      <label>regexp</label>
-      <input type="hidden" name="setting[format]" value="regexp" />
-      <input type="text" name="setting[regexp]" v-model="regexp" size="100%" />
-    </div>
-    <div class="form-group">
-      <label>time_format</label>
-      <input type="text" name="setting[time_format]" v-model="time_format" size="100%" />
-    </div>
-  </div>
+<div id="in_tail_format" class="form-group"
+  formatOptionsJson="<%= formats.to_json %>"
+  initialSelected="<%= initialSelected %>"
+  targetFile="<%= file %>"
+  paramsJson="<%= params.to_json %>"
+  >
+
+  <div v-component="format-bundle"></div>
 
   <pre>{{{ highlightedLines }}}</pre>
 
diff --git a/bower.json b/bower.json
index e143c1d..c1dd6ec 100644
--- a/bower.json
+++ b/bower.json
@@ -2,7 +2,7 @@
   "name": "fluentd-ui",
   "dependencies": {
     "es6-promise": "~1.0.0",
-    "vue": "~0.10.0",
+    "vue": "~0.11.0",
     "lodash": "~2.4.0"
   },
   "devDependencies": {
diff --git a/vendor/assets/javascripts/bower/vue/.bower.json b/vendor/assets/javascripts/bower/vue/.bower.json
index 30a2288..ff27e96 100644
--- a/vendor/assets/javascripts/bower/vue/.bower.json
+++ b/vendor/assets/javascripts/bower/vue/.bower.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "0.10.6",
+  "version": "0.11.0",
   "main": "dist/vue.js",
   "description": "Simple, Fast & Composable MVVM for building interative interfaces",
   "authors": [
@@ -11,19 +11,19 @@
     ".*",
     "examples",
     "test",
-    "tasks",
-    "Gruntfile.js",
+    "grunt",
+    "gruntfile.js",
     "*.json",
     "*.md"
   ],
   "homepage": "https://github.com/yyx990803/vue",
-  "_release": "0.10.6",
+  "_release": "0.11.0",
   "_resolution": {
     "type": "version",
-    "tag": "v0.10.6",
-    "commit": "cf37f7efd6d63c0aa46b50c624816e645ddd7edd"
+    "tag": "0.11.0",
+    "commit": "5bc3e30b694dc3b6aeeb87c24f88b9cd7a7259d6"
   },
   "_source": "git://github.com/yyx990803/vue.git",
-  "_target": "~0.10.0",
+  "_target": "~0.11.0",
   "_originalSource": "vue"
 }
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/LICENSE b/vendor/assets/javascripts/bower/vue/LICENSE
index 17a9b2f..405481c 100644
--- a/vendor/assets/javascripts/bower/vue/LICENSE
+++ b/vendor/assets/javascripts/bower/vue/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2013 Yuxi Evan You
+Copyright (c) 2013-2014 Yuxi Evan You
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/vendor/assets/javascripts/bower/vue/dist/vue.js b/vendor/assets/javascripts/bower/vue/dist/vue.js
index a747ba9..ab0eefc 100644
--- a/vendor/assets/javascripts/bower/vue/dist/vue.js
+++ b/vendor/assets/javascripts/bower/vue/dist/vue.js
@@ -1,4772 +1,7615 @@
-/*
- Vue.js v0.10.6
- (c) 2014 Evan You
- License: MIT
-*/
-;(function(){
-'use strict';
-
 /**
- * Require the given path.
- *
- * @param {String} path
- * @return {Object} exports
- * @api public
+ * Vue.js v0.11.0
+ * (c) 2014 Evan You
+ * Released under the MIT License.
  */
 
-function require(path, parent, orig) {
-  var resolved = require.resolve(path);
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define(factory);
+	else if(typeof exports === 'object')
+		exports["Vue"] = factory();
+	else
+		root["Vue"] = factory();
+})(this, function() {
+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);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
 
-  // lookup failed
-  if (null == resolved) {
-    throwError()
-    return
-  }
+	var _ = __webpack_require__(1)
+	var extend = _.extend
 
-  var module = require.modules[resolved];
+	/**
+	 * The exposed Vue constructor.
+	 *
+	 * API conventions:
+	 * - public API methods/properties are prefiexed with `$`
+	 * - internal methods/properties are prefixed with `_`
+	 * - non-prefixed properties are assumed to be proxied user
+	 *   data.
+	 *
+	 * @constructor
+	 * @param {Object} [options]
+	 * @public
+	 */
 
-  // perform real require()
-  // by invoking the module's
-  // registered function
-  if (!module._resolving && !module.exports) {
-    var mod = {};
-    mod.exports = {};
-    mod.client = mod.component = true;
-    module._resolving = true;
-    module.call(this, mod.exports, require.relative(resolved), mod);
-    delete module._resolving;
-    module.exports = mod.exports;
-  }
+	function Vue (options) {
+	  this._init(options)
+	}
 
-  function throwError () {
-    orig = orig || path;
-    parent = parent || 'root';
-    var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
-    err.path = orig;
-    err.parent = parent;
-    err.require = true;
-    throw err;
-  }
+	/**
+	 * Mixin global API
+	 */
 
-  return module.exports;
-}
+	extend(Vue, __webpack_require__(2))
 
-/**
- * Registered modules.
- */
+	/**
+	 * Vue and every constructor that extends Vue has an
+	 * associated options object, which can be accessed during
+	 * compilation steps as `this.constructor.options`.
+	 *
+	 * These can be seen as the default options of every
+	 * Vue instance.
+	 */
 
-require.modules = {};
+	Vue.options = {
+	  directives  : __webpack_require__(8),
+	  filters     : __webpack_require__(9),
+	  partials    : {},
+	  transitions : {},
+	  components  : {}
+	}
 
-/**
- * Registered aliases.
- */
+	/**
+	 * Build up the prototype
+	 */
 
-require.aliases = {};
+	var p = Vue.prototype
 
-/**
- * Resolve `path`.
- *
- * Lookup:
- *
- *   - PATH/index.js
- *   - PATH.js
- *   - PATH
- *
- * @param {String} path
- * @return {String} path or null
- * @api private
- */
+	/**
+	 * $data has a setter which does a bunch of
+	 * teardown/setup work
+	 */
 
-require.exts = [
-    '',
-    '.js',
-    '.json',
-    '/index.js',
-    '/index.json'
- ];
+	Object.defineProperty(p, '$data', {
+	  get: function () {
+	    return this._data
+	  },
+	  set: function (newData) {
+	    this._setData(newData)
+	  }
+	})
 
-require.resolve = function(path) {
-  if (path.charAt(0) === '/') path = path.slice(1);
+	/**
+	 * Mixin internal instance methods
+	 */
 
-  for (var i = 0; i < 5; i++) {
-    var fullPath = path + require.exts[i];
-    if (require.modules.hasOwnProperty(fullPath)) return fullPath;
-    if (require.aliases.hasOwnProperty(fullPath)) return require.aliases[fullPath];
-  }
-};
+	extend(p, __webpack_require__(10))
+	extend(p, __webpack_require__(11))
+	extend(p, __webpack_require__(12))
+	extend(p, __webpack_require__(13))
 
-/**
- * Normalize `path` relative to the current path.
- *
- * @param {String} curr
- * @param {String} path
- * @return {String}
- * @api private
- */
+	/**
+	 * Mixin public API methods
+	 */
 
-require.normalize = function(curr, path) {
+	extend(p, __webpack_require__(3))
+	extend(p, __webpack_require__(4))
+	extend(p, __webpack_require__(5))
+	extend(p, __webpack_require__(6))
+	extend(p, __webpack_require__(7))
 
-  var segs = [];
+	module.exports = _.Vue = Vue
 
-  if ('.' != path.charAt(0)) return path;
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
 
-  curr = curr.split('/');
-  path = path.split('/');
+	var lang   = __webpack_require__(14)
+	var extend = lang.extend
 
-  for (var i = 0; i < path.length; ++i) {
-    if ('..' === path[i]) {
-      curr.pop();
-    } else if ('.' != path[i] && '' != path[i]) {
-      segs.push(path[i]);
-    }
-  }
-  return curr.concat(segs).join('/');
-};
+	extend(exports, lang)
+	extend(exports, __webpack_require__(15))
+	extend(exports, __webpack_require__(16))
+	extend(exports, __webpack_require__(17))
+	extend(exports, __webpack_require__(18))
 
-/**
- * Register module at `path` with callback `definition`.
- *
- * @param {String} path
- * @param {Function} definition
- * @api private
- */
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
 
-require.register = function(path, definition) {
-  require.modules[path] = definition;
-};
+	var _ = __webpack_require__(1)
+	var mergeOptions = __webpack_require__(19)
 
-/**
- * Alias a module definition.
- *
- * @param {String} from
- * @param {String} to
- * @api private
- */
+	/**
+	 * Expose useful internals
+	 */
 
-require.alias = function(from, to) {
-  if (!require.modules.hasOwnProperty(from)) {
-    throwError()
-    return
-  }
-  require.aliases[to] = from;
+	exports.util       = _
+	exports.nextTick   = _.nextTick
+	exports.config     = __webpack_require__(20)
 
-  function throwError () {
-    throw new Error('Failed to alias "' + from + '", it does not exist');
-  }
-};
+	/**
+	 * Each instance constructor, including Vue, has a unique
+	 * cid. This enables us to create wrapped "child
+	 * constructors" for prototypal inheritance and cache them.
+	 */
 
-/**
- * Return a require function relative to the `parent` path.
- *
- * @param {String} parent
- * @return {Function}
- * @api private
- */
+	exports.cid = 0
+	var cid = 1
 
-require.relative = function(parent) {
-  var p = require.normalize(parent, '..');
+	/**
+	 * Class inehritance
+	 *
+	 * @param {Object} extendOptions
+	 */
 
-  /**
-   * The relative require() itself.
-   */
+	exports.extend = function (extendOptions) {
+	  extendOptions = extendOptions || {}
+	  var Super = this
+	  var Sub = createClass(extendOptions.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
+	}
 
-  function localRequire(path) {
-    var resolved = localRequire.resolve(path);
-    return require(resolved, parent, path);
-  }
+	/**
+	 * 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}
+	 */
 
-  /**
-   * Resolve relative to the parent.
-   */
+	function createClass (name) {
+	  return new Function(
+	    'return function ' + _.camelize(name, true) +
+	    ' (options) { this._init(options) }'
+	  )()
+	}
 
-  localRequire.resolve = function(path) {
-    var c = path.charAt(0);
-    if ('/' === c) return path.slice(1);
-    if ('.' === c) return require.normalize(p, path);
+	/**
+	 * Plugin system
+	 *
+	 * @param {Object} plugin
+	 */
 
-    // resolve deps by returning
-    // the dep in the nearest "deps"
-    // directory
-    var segs = parent.split('/');
-    var i = segs.length;
-    while (i--) {
-      if (segs[i] === 'deps') {
-        break;
-      }
-    }
-    path = segs.slice(0, i + 2).join('/') + '/deps/' + path;
-    return path;
-  };
+	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
+	}
 
-  /**
-   * Check if module is defined at `path`.
-   */
+	/**
+	 * Define asset registration methods on a constructor.
+	 *
+	 * @param {Function} Constructor
+	 */
 
-  localRequire.exists = function(path) {
-    return require.modules.hasOwnProperty(localRequire.resolve(path));
-  };
+	var assetTypes = [
+	  'directive',
+	  'filter',
+	  'partial',
+	  'transition'
+	]
 
-  return localRequire;
-};
-require.register("vue/src/main.js", function(exports, require, module){
-var config      = require('./config'),
-    ViewModel   = require('./viewmodel'),
-    utils       = require('./utils'),
-    makeHash    = utils.hash,
-    assetTypes  = ['directive', 'filter', 'partial', 'effect', 'component'],
-    // Internal modules that are exposed for plugins
-    pluginAPI   = {
-        utils: utils,
-        config: config,
-        transition: require('./transition'),
-        observer: require('./observer')
-    }
+	function createAssetRegisters (Constructor) {
 
-ViewModel.options = config.globalAssets = {
-    directives  : require('./directives'),
-    filters     : require('./filters'),
-    partials    : makeHash(),
-    effects     : makeHash(),
-    components  : makeHash()
-}
+	  /* Asset registration methods share the same signature:
+	   *
+	   * @param {String} id
+	   * @param {*} definition
+	   */
 
-/**
- *  Expose asset registration methods
- */
-assetTypes.forEach(function (type) {
-    ViewModel[type] = function (id, value) {
-        var hash = this.options[type + 's']
-        if (!hash) {
-            hash = this.options[type + 's'] = makeHash()
-        }
-        if (!value) return hash[id]
-        if (type === 'partial') {
-            value = utils.parseTemplateOption(value)
-        } else if (type === 'component') {
-            value = utils.toConstructor(value)
-        } else if (type === 'filter') {
-            utils.checkFilter(value)
-        }
-        hash[id] = value
-        return this
-    }
-})
+	  assetTypes.forEach(function (type) {
+	    Constructor[type] = function (id, definition) {
+	      if (!definition) {
+	        return this.options[type + 's'][id]
+	      } else {
+	        this.options[type + 's'][id] = definition
+	      }
+	    }
+	  })
 
-/**
- *  Set config options
- */
-ViewModel.config = function (opts, val) {
-    if (typeof opts === 'string') {
-        if (val === undefined) {
-            return config[opts]
-        } else {
-            config[opts] = val
-        }
-    } else {
-        utils.extend(config, opts)
-    }
-    return this
-}
+	  /**
+	   * Component registration needs to automatically invoke
+	   * Vue.extend on object values.
+	   *
+	   * @param {String} id
+	   * @param {Object|Function} definition
+	   */
 
-/**
- *  Expose an interface for plugins
- */
-ViewModel.use = function (plugin) {
-    if (typeof plugin === 'string') {
-        try {
-            plugin = require(plugin)
-        } catch (e) {
-            utils.warn('Cannot find plugin: ' + plugin)
-            return
-        }
-    }
+	  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
+	    }
+	  }
+	}
 
-    // additional parameters
-    var args = [].slice.call(arguments, 1)
-    args.unshift(this)
+	createAssetRegisters(exports)
 
-    if (typeof plugin.install === 'function') {
-        plugin.install.apply(plugin, args)
-    } else {
-        plugin.apply(null, args)
-    }
-    return this
-}
+/***/ },
+/* 3 */
+/***/ function(module, exports, __webpack_require__) {
 
-/**
- *  Expose internal modules for plugins
- */
-ViewModel.require = function (module) {
-    return pluginAPI[module]
-}
+	var _ = __webpack_require__(1)
+	var Watcher = __webpack_require__(21)
+	var Path = __webpack_require__(41)
+	var textParser = __webpack_require__(42)
+	var dirParser = __webpack_require__(43)
+	var expParser = __webpack_require__(44)
+	var filterRE = /[^|]\|[^|]/
 
-ViewModel.extend = extend
-ViewModel.nextTick = utils.nextTick
+	/**
+	 * Get the value from an expression on this vm.
+	 *
+	 * @param {String} exp
+	 * @return {*}
+	 */
 
-/**
- *  Expose the main ViewModel class
- *  and add extend method
- */
-function extend (options) {
+	exports.$get = function (exp) {
+	  var res = expParser.parse(exp)
+	  if (res) {
+	    return res.get.call(this, this)
+	  }
+	}
 
-    var ParentVM = this
+	/**
+	 * Set the value from an expression on this vm.
+	 * The expression must be a valid left-hand
+	 * expression in an assignment.
+	 *
+	 * @param {String} exp
+	 * @param {*} val
+	 */
 
-    // extend data options need to be copied
-    // on instantiation
-    if (options.data) {
-        options.defaultData = options.data
-        delete options.data
-    }
+	exports.$set = function (exp, val) {
+	  var res = expParser.parse(exp, true)
+	  if (res && res.set) {
+	    res.set.call(this, this, val)
+	  }
+	}
 
-    // inherit options
-    // but only when the super class is not the native Vue.
-    if (ParentVM !== ViewModel) {
-        options = inheritOptions(options, ParentVM.options, true)
-    }
-    utils.processOptions(options)
+	/**
+	 * Add a property on the VM
+	 *
+	 * @param {String} key
+	 * @param {*} val
+	 */
 
-    var ExtendedVM = function (opts, asParent) {
-        if (!asParent) {
-            opts = inheritOptions(opts, options, true)
-        }
-        ParentVM.call(this, opts, true)
-    }
+	exports.$add = function (key, val) {
+	  this._data.$add(key, val)
+	}
 
-    // inherit prototype props
-    var proto = ExtendedVM.prototype = Object.create(ParentVM.prototype)
-    utils.defProtected(proto, 'constructor', ExtendedVM)
+	/**
+	 * Delete a property on the VM
+	 *
+	 * @param {String} key
+	 */
 
-    // allow extended VM to be further extended
-    ExtendedVM.extend  = extend
-    ExtendedVM.super   = ParentVM
-    ExtendedVM.options = options
+	exports.$delete = function (key) {
+	  this._data.$delete(key)
+	}
 
-    // allow extended VM to add its own assets
-    assetTypes.forEach(function (type) {
-        ExtendedVM[type] = ViewModel[type]
-    })
+	/**
+	 * Watch an expression, trigger callback when its
+	 * value changes.
+	 *
+	 * @param {String} exp
+	 * @param {Function} cb
+	 * @param {Boolean} [deep]
+	 * @param {Boolean} [immediate]
+	 * @return {Function} - unwatchFn
+	 */
 
-    // allow extended VM to use plugins
-    ExtendedVM.use     = ViewModel.use
-    ExtendedVM.require = ViewModel.require
+	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, null, false, deep)
+	  } else {
+	    watcher.addCb(wrappedCb)
+	  }
+	  if (immediate) {
+	    wrappedCb(watcher.value)
+	  }
+	  return function unwatchFn () {
+	    watcher.removeCb(wrappedCb)
+	    if (!watcher.active) {
+	      vm._userWatchers[key] = null
+	    }
+	  }
+	}
 
-    return ExtendedVM
-}
+	/**
+	 * Evaluate a text directive, including filters.
+	 *
+	 * @param {String} text
+	 * @return {String}
+	 */
 
-/**
- *  Inherit options
- *
- *  For options such as `data`, `vms`, `directives`, 'partials',
- *  they should be further extended. However extending should only
- *  be done at top level.
- *  
- *  `proto` is an exception because it's handled directly on the
- *  prototype.
- *
- *  `el` is an exception because it's not allowed as an
- *  extension option, but only as an instance option.
- */
-function inheritOptions (child, parent, topLevel) {
-    child = child || {}
-    if (!parent) return child
-    for (var key in parent) {
-        if (key === 'el') continue
-        var val = child[key],
-            parentVal = parent[key]
-        if (topLevel && typeof val === 'function' && parentVal) {
-            // merge hook functions into an array
-            child[key] = [val]
-            if (Array.isArray(parentVal)) {
-                child[key] = child[key].concat(parentVal)
-            } else {
-                child[key].push(parentVal)
-            }
-        } else if (
-            topLevel &&
-            (utils.isTrueObject(val) || utils.isTrueObject(parentVal))
-            && !(parentVal instanceof ViewModel)
-        ) {
-            // merge toplevel object options
-            child[key] = inheritOptions(val, parentVal)
-        } else if (val === undefined) {
-            // inherit if child doesn't override
-            child[key] = parentVal
-        }
-    }
-    return child
-}
+	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)
+	  } else {
+	    // no filter
+	    return this.$get(text)
+	  }
+	}
 
-module.exports = ViewModel
+	/**
+	 * Interpolate a piece of template text.
+	 *
+	 * @param {String} text
+	 * @return {String}
+	 */
+
+	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, path)
+	    : this._data
+	  console.log(JSON.parse(JSON.stringify(data)))
+	}
+
+/***/ },
+/* 4 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var transition = __webpack_require__(45)
+
+	/**
+	 * Append instance to target
+	 *
+	 * @param {Node} target
+	 * @param {Function} [cb]
+	 * @param {Boolean} [withTransition] - defaults to true
+	 */
+
+	exports.$appendTo = function (target, cb, withTransition) {
+	  target = query(target)
+	  var targetIsDetached = !_.inDoc(target)
+	  var op = withTransition === false || targetIsDetached
+	    ? append
+	    : transition.append
+	  insert(this, target, op, targetIsDetached, cb)
+	  return this
+	}
+
+	/**
+	 * 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) {
+	  target = query(target)
+	  var targetIsDetached = !_.inDoc(target)
+	  var op = withTransition === false || targetIsDetached
+	    ? before
+	    : transition.before
+	  insert(this, target, op, targetIsDetached, cb)
+	  return this
+	}
+
+	/**
+	 * Insert instance after target
+	 *
+	 * @param {Node} target
+	 * @param {Function} [cb]
+	 * @param {Boolean} [withTransition] - defaults to true
+	 */
+
+	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
+	}
+
+	/**
+	 * Remove instance from DOM
+	 *
+	 * @param {Function} [cb]
+	 * @param {Boolean} [withTransition] - defaults to true
+	 */
+
+	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
+	}
+
+	/**
+	 * Shared DOM insertion function.
+	 *
+	 * @param {Vue} vm
+	 * @param {Element} target
+	 * @param {Function} op
+	 * @param {Boolean} targetIsDetached
+	 * @param {Function} [cb]
+	 */
+
+	function insert (vm, target, op, targetIsDetached, cb) {
+	  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')
+	  }
+	}
+
+	/**
+	 * 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
+	 */
+
+	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)
+	}
+
+	/**
+	 * Check for selectors
+	 *
+	 * @param {String|Element} el
+	 */
+
+	function query (el) {
+	  return typeof el === 'string'
+	    ? document.querySelector(el)
+	    : el
+	}
+
+	/**
+	 * Append operation that takes a callback.
+	 *
+	 * @param {Node} el
+	 * @param {Node} target
+	 * @param {Vue} vm - unused
+	 * @param {Function} [cb]
+	 */
+
+	function append (el, target, vm, cb) {
+	  target.appendChild(el)
+	  if (cb) cb()
+	}
+
+	/**
+	 * InsertBefore operation that takes a callback.
+	 *
+	 * @param {Node} el
+	 * @param {Node} target
+	 * @param {Vue} vm - unused
+	 * @param {Function} [cb]
+	 */
+
+	function before (el, target, vm, cb) {
+	  _.before(el, target)
+	  if (cb) cb()
+	}
+
+	/**
+	 * Remove operation that takes a callback.
+	 *
+	 * @param {Node} el
+	 * @param {Vue} vm - unused
+	 * @param {Function} [cb]
+	 */
+
+	function remove (el, vm, cb) {
+	  _.remove(el)
+	  if (cb) cb()
+	}
+
+/***/ },
+/* 5 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	/**
+	 * 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
+	}
+
+	/**
+	 * Adds an `event` listener that will be invoked a single
+	 * time then automatically removed.
+	 *
+	 * @param {String} event
+	 * @param {Function} fn
+	 */
+
+	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
+	}
+
+	/**
+	 * Remove the given callback for `event` or all
+	 * registered callbacks.
+	 *
+	 * @param {String} event
+	 * @param {Function} fn
+	 */
+
+	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)
+	        }
+	      }
+	    }
+	    this._events = {}
+	    return this
+	  }
+	  // specific event
+	  cbs = this._events[event]
+	  if (!cbs) {
+	    return this
+	  }
+	  if (arguments.length === 1) {
+	    modifyListenerCount(this, event, -cbs.length)
+	    this._events[event] = null
+	    return this
+	  }
+	  // specific handler
+	  var cb
+	  var i = cbs.length
+	  while (i--) {
+	    cb = cbs[i]
+	    if (cb === fn || cb.fn === fn) {
+	      modifyListenerCount(this, event, -1)
+	      cbs.splice(i, 1)
+	      break
+	    }
+	  }
+	  return this
+	}
+
+	/**
+	 * Trigger an event on self.
+	 *
+	 * @param {String} event
+	 */
+
+	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
+	      }
+	    }
+	  }
+	  return this
+	}
+
+	/**
+	 * Recursively broadcast an event to all children instances.
+	 *
+	 * @param {String} event
+	 * @param {...*} additional arguments
+	 */
+
+	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
+	  if (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)
+	      }
+	    }
+	  }
+	  return this
+	}
+
+	/**
+	 * Recursively propagate an event up the parent chain.
+	 *
+	 * @param {String} event
+	 * @param {...*} additional arguments
+	 */
+
+	exports.$dispatch = function () {
+	  var parent = this.$parent
+	  while (parent) {
+	    parent.$emit.apply(parent, arguments)
+	    parent = parent._eventCancelled
+	      ? null
+	      : parent.$parent
+	  }
+	  return this
+	}
+
+	/**
+	 * Modify the listener counts on all parents.
+	 * This bookkeeping allows $broadcast to return early when
+	 * no child has listened to a certain event.
+	 *
+	 * @param {Vue} vm
+	 * @param {String} event
+	 * @param {Number} count
+	 */
+
+	var hookRE = /^hook:/
+	function modifyListenerCount (vm, event, count) {
+	  var parent = vm.$parent
+	  // hooks do not get broadcasted so no need
+	  // to do bookkeeping for them
+	  if (!parent || !count || hookRE.test(event)) return
+	  while (parent) {
+	    parent._eventsCount[event] =
+	      (parent._eventsCount[event] || 0) + count
+	    parent = parent.$parent
+	  }
+	}
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	/**
+	 * 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
+	 */
+
+	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
+	    if (!ctors) {
+	      ctors = parent._childCtors = {}
+	    }
+	    ChildVue = ctors[BaseCtor.cid]
+	    if (!ChildVue) {
+	      var optionName = BaseCtor.options.name
+	      var className = optionName
+	        ? _.camelize(optionName, true)
+	        : '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
+	  }
+	  opts._parent = parent
+	  opts._root = parent.$root
+	  var child = new ChildVue(opts)
+	  if (!this._children) {
+	    this._children = []
+	  }
+	  this._children.push(child)
+	  return child
+	}
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var compile = __webpack_require__(46)
+
+	/**
+	 * 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
+	    }
+	  }
+	  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
+	}
+
+	/**
+	 * Mark an instance as ready.
+	 */
+
+	function ready () {
+	  this._isAttached = true
+	  this._isReady = true
+	  this._callHook('ready')
+	}
+
+	/**
+	 * Teardown an instance, unobserves the data, unbind all the
+	 * directives, turn off all the event listeners, etc.
+	 *
+	 * @param {Boolean} remove - whether to remove the DOM node.
+	 * @public
+	 */
+
+	exports.$destroy = function (remove) {
+	  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) {
+	    i = parent._children.indexOf(this)
+	    parent._children.splice(i, 1)
+	  }
+	  // destroy all children.
+	  if (this._children) {
+	    i = this._children.length
+	    while (i--) {
+	      this._children[i].$destroy()
+	    }
+	  }
+	  // teardown all directives. this also tearsdown all
+	  // directive-owned watchers.
+	  i = this._directives.length
+	  while (i--) {
+	    this._directives[i]._teardown()
+	  }
+	  // teardown all user watchers.
+	  for (i in this._userWatchers) {
+	    this._userWatchers[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 () {
+	      cleanup(self)
+	    })
+	  } else {
+	    cleanup(self)
+	  }
+	}
+
+	/**
+	 * Clean up to ensure garbage collection.
+	 * This is called after the leave transition if there
+	 * is any.
+	 *
+	 * @param {Vue} vm
+	 */
+
+	function cleanup (vm) {
+	  // remove reference from data ob
+	  vm._data.__ob__.removeVm(vm)
+	  vm._data =
+	  vm._watchers =
+	  vm._userWatchers =
+	  vm._watcherList =
+	  vm.$el =
+	  vm.$parent =
+	  vm.$root =
+	  vm._children =
+	  vm._bindings =
+	  vm._directives = null
+	  // call the last hook...
+	  vm._isDestroyed = true
+	  vm._callHook('destroyed')
+	  // turn off all instance listeners.
+	  vm.$off() 
+	}
+
+	/**
+	 * 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)
+	}
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// manipulation directives
+	exports.text       = __webpack_require__(22)
+	exports.html       = __webpack_require__(23)
+	exports.attr       = __webpack_require__(24)
+	exports.show       = __webpack_require__(25)
+	exports['class']   = __webpack_require__(26)
+	exports.el         = __webpack_require__(27)
+	exports.ref        = __webpack_require__(28)
+	exports.cloak      = __webpack_require__(29)
+	exports.style      = __webpack_require__(30)
+	exports.partial    = __webpack_require__(31)
+	exports.transition = __webpack_require__(32)
+
+	// event listener directives
+	exports.on         = __webpack_require__(33)
+	exports.model      = __webpack_require__(48)
+
+	// child vm directives
+	exports.component  = __webpack_require__(34)
+	exports.repeat     = __webpack_require__(35)
+	exports['if']      = __webpack_require__(36)
+	exports['with']    = __webpack_require__(37)
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	/**
+	 * Stringify value.
+	 *
+	 * @param {Number} indent
+	 */
+
+	exports.json = function (value, indent) {
+	  return JSON.stringify(value, null, Number(indent) || 2)
+	}
+
+	/**
+	 * '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 (!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 ? ',' : ''))
+	      : '',
+	    f = '.' + value.toFixed(2).slice(-2)
+	  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.
+	 *
+	 *  e.g. ['single', 'double', 'triple', 'multiple']
+	 */
+
+	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'))
+	}
+
+	/**
+	 * A special filter that takes a handler function,
+	 * wraps it so it only gets triggered on specific
+	 * keypresses. v-on only.
+	 *
+	 * @param {String} key
+	 */
+
+	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)
+	    }
+	  }
+	}
+
+	/**
+	 * Install special array filters
+	 */
+
+	_.extend(exports, __webpack_require__(38))
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var mergeOptions = __webpack_require__(19)
+
+	/**
+	 * 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._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
+
+	  // children
+	  this._children =         // @type {Array}
+	  this._childCtors = null  // @type {Object} - hash to cache
+	                           // child constructors
+
+	  // 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)
+	  }
+	}
+
+/***/ },
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	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.
+	 */
+
+	exports._initEvents = function () {
+	  var options = this.$options
+	  registerCallbacks(this, '$on', options.events)
+	  registerCallbacks(this, '$watch', options.watch)
+	}
+
+	/**
+	 * Register callbacks for option events and watchers.
+	 *
+	 * @param {Vue} vm
+	 * @param {String} action
+	 * @param {Object} hash
+	 */
+
+	function registerCallbacks (vm, action, hash) {
+	  if (!hash) return
+	  var handlers, key, i, j
+	  for (key in hash) {
+	    handlers = hash[key]
+	    if (_.isArray(handlers)) {
+	      for (i = 0, j = handlers.length; i < j; i++) {
+	        register(vm, action, key, handlers[i])
+	      }
+	    } else {
+	      register(vm, action, key, handlers)
+	    }
+	  }
+	}
+
+	/**
+	 * Helper to register an event/watch callback.
+	 *
+	 * @param {Vue} vm
+	 * @param {String} action
+	 * @param {String} key
+	 * @param {*} handler
+	 */
+
+	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)
+	}
+
+	/**
+	 * Callback to recursively call attached hook on children
+	 */
+
+	function onAttached () {
+	  this._isAttached = true
+	  var children = this._children
+	  if (!children) return
+	  for (var i = 0, l = children.length; i < l; i++) {
+	    var child = children[i]
+	    if (!child._isAttached && inDoc(child.$el)) {
+	      child._callHook('attached')
+	    }
+	  }
+	}
+
+	/**
+	 * Callback to recursively call detached hook on children
+	 */
+
+	function onDetached () {
+	  this._isAttached = false
+	  var children = this._children
+	  if (!children) return
+	  for (var i = 0, l = children.length; i < l; i++) {
+	    var child = children[i]
+	    if (child._isAttached && !inDoc(child.$el)) {
+	      child._callHook('detached')
+	    }
+	  }
+	}
+
+	/**
+	 * Trigger all handlers for a hook
+	 *
+	 * @param {String} hook
+	 */
+
+	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)
+	}
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var Observer = __webpack_require__(49)
+	var Binding = __webpack_require__(39)
+
+	/**
+	 * 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. 
+	 */
+
+	exports._initData = function () {
+	  // proxy data on instance
+	  var data = this._data
+	  var keys = Object.keys(data)
+	  var i = keys.length
+	  var key
+	  while (i--) {
+	    key = keys[i]
+	    if (!_.isReserved(key)) {
+	      this._proxy(key)
+	    }
+	  }
+	  // observe data
+	  Observer.create(data).addVm(this)
+	}
+
+	/**
+	 * Swap the isntance's $data. Called in $data's setter.
+	 *
+	 * @param {Object} newData
+	 */
+
+	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)
+	    }
+	  }
+	  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
+	    }
+	  })
+	}
+
+	/**
+	 * Unproxy a property.
+	 *
+	 * @param {String} key
+	 */
+
+	exports._unproxy = function (key) {
+	  delete this[key]
+	}
+
+	/**
+	 * Force update on every watcher in scope.
+	 */
+
+	exports._digest = function () {
+	  var i = this._watcherList.length
+	  while (i--) {
+	    this._watcherList[i].update()
+	  }
+	  var children = this._children
+	  var child
+	  if (children) {
+	    i = children.length
+	    while (i--) {
+	      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)
+	    }
+	  }
+	}
+
+	/**
+	 * Initialize meta information like $index, $key & $value.
+	 */
+
+	exports._initMeta = function () {
+	  var metas = this.$options._meta
+	  if (metas) {
+	    for (var key in metas) {
+	      this._defineMeta(key, metas[key])
+	    }
+	  }
+	}
+
+	/**
+	 * 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
+	 */
+
+	exports._defineMeta = function (key, value) {
+	  var binding = new Binding()
+	  Object.defineProperty(this, key, {
+	    enumerable: true,
+	    configurable: true,
+	    get: function metaGetter () {
+	      if (Observer.target) {
+	        Observer.target.addDep(binding)
+	      }
+	      return value
+	    },
+	    set: function metaSetter (val) {
+	      if (val !== value) {
+	        value = val
+	        binding.notify()
+	      }
+	    }
+	  })
+	}
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var Directive = __webpack_require__(40)
+	var compile = __webpack_require__(46)
+	var transclude = __webpack_require__(47)
+
+	/**
+	 * 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._compile = function (el) {
+	  var options = this.$options
+	  if (options._linker) {
+	    this._initElement(el)
+	    options._linker(this, el)
+	  } else {
+	    var raw = el
+	    el = transclude(el, options)
+	    this._initElement(el)
+	    var linker = compile(el, options)
+	    linker(this, el)
+	    if (options.replace) {
+	      _.replace(raw, el)
+	    }
+	  }
+	  return el
+	}
+
+	/**
+	 * Initialize instance element. Called in the public
+	 * $mount() method.
+	 *
+	 * @param {Element} el
+	 */
+
+	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')
+	}
+
+	/**
+	 * Create and bind a directive to an element.
+	 *
+	 * @param {String} name - directive name
+	 * @param {Node} node   - target node
+	 * @param {Object} desc - parsed directive descriptor
+	 * @param {Object} def  - directive definition object
+	 * @param {Function} [linker] - pre-compiled linker fn
+	 */
+
+	exports._bindDir = function (name, node, desc, def, linker) {
+	  this._directives.push(
+	    new Directive(name, node, this, desc, def, linker)
+	  )
+	}
+
+/***/ },
+/* 14 */
+/***/ 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
+	}
+
+	/**
+	 * Guard text output, make sure undefined outputs
+	 * empty string
+	 *
+	 * @param {*} value
+	 * @return {String}
+	 */
+
+	exports.toString = function (value) {
+	  return value == null
+	    ? ''
+	    : value.toString()
+	}
+
+	/**
+	 * 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)
+	}
+
+	/**
+	 * Strip quotes from a string
+	 *
+	 * @param {String} str
+	 * @return {String | false}
+	 */
+
+	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
+	}
+
+	/**
+	 * Camelize a hyphen-delmited string.
+	 *
+	 * @param {String} str
+	 * @return {String}
+	 */
+
+	var camelRE = /[-_](\w)/g
+	var capitalCamelRE = /(?:^|[-_])(\w)/g
+
+	exports.camelize = function (str, cap) {
+	  var RE = cap ? capitalCamelRE : camelRE
+	  return str.replace(RE, function (_, c) {
+	    return c ? c.toUpperCase () : '';
+	  })
+	}
+
+	/**
+	 * Simple bind, faster than native
+	 *
+	 * @param {Function} fn
+	 * @param {Object} ctx
+	 * @return {Function}
+	 */
+
+	exports.bind = function (fn, ctx) {
+	  return function () {
+	    return fn.apply(ctx, arguments)
+	  }
+	}
+
+	/**
+	 * Convert an Array-like object to a real Array.
+	 *
+	 * @param {Array-like} list
+	 * @param {Number} [start] - start index
+	 * @return {Array}
+	 */
+
+	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]
+	  }
+	  return ret
+	}
+
+	/**
+	 * Mix properties into target object.
+	 *
+	 * @param {Object} to
+	 * @param {Object} from
+	 */
+
+	exports.extend = function (to, from) {
+	  for (var key in from) {
+	    to[key] = from[key]
+	  }
+	}
+
+	/**
+	 * 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
+	 *
+	 * @param {Object} obj
+	 * @param {String} key
+	 * @param {*} val
+	 * @param {Boolean} [enumerable]
+	 */
+
+	exports.define = function (obj, key, val, enumerable) {
+	  Object.defineProperty(obj, key, {
+	    value        : val,
+	    enumerable   : !!enumerable,
+	    writable     : true,
+	    configurable : true
+	  })
+	}
+
+/***/ },
+/* 15 */
+/***/ 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 the start of the next event loop
+	 *
+	 * @param {Function} cb
+	 * @param {Object} ctx
+	 */
+
+	var defer = inBrowser
+	  ? (window.requestAnimationFrame ||
+	    window.webkitRequestAnimationFrame ||
+	    setTimeout)
+	  : setTimeout
+
+	exports.nextTick = function (cb, ctx) {
+	  if (ctx) {
+	    defer(function () { cb.call(ctx) }, 0)
+	  } else {
+	    defer(cb, 0)
+	  }
+	}
+
+	/**
+	 * 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'
+	}
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var config = __webpack_require__(20)
+
+	/**
+	 * Check if a node is in the document.
+	 *
+	 * @param {Node} node
+	 * @return {Boolean}
+	 */
+
+	var doc =
+	  typeof document !== 'undefined' &&
+	  document.documentElement
+
+	exports.inDoc = function (node) {
+	  return doc && doc.contains(node)
+	}
+
+	/**
+	 * Extract an attribute from a node.
+	 *
+	 * @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
+	 *
+	 * @param {Element} el
+	 * @param {Element} target 
+	 */
+
+	exports.before = function (el, target) {
+	  target.parentNode.insertBefore(el, target)
+	}
+
+	/**
+	 * Insert el after target
+	 *
+	 * @param {Element} el
+	 * @param {Element} target 
+	 */
+
+	exports.after = function (el, target) {
+	  if (target.nextSibling) {
+	    exports.before(el, target.nextSibling)
+	  } else {
+	    target.parentNode.appendChild(el)
+	  }
+	}
+
+	/**
+	 * Remove el from DOM
+	 *
+	 * @param {Element} el
+	 */
+
+	exports.remove = function (el) {
+	  el.parentNode.removeChild(el)
+	}
+
+	/**
+	 * Prepend el to target
+	 *
+	 * @param {Element} el
+	 * @param {Element} target 
+	 */
+
+	exports.prepend = function (el, target) {
+	  if (target.firstChild) {
+	    exports.before(el, target.firstChild)
+	  } else {
+	    target.appendChild(el)
+	  }
+	}
+
+	/**
+	 * Replace target with el
+	 *
+	 * @param {Element} target
+	 * @param {Element} el
+	 */
+
+	exports.replace = function (target, el) {
+	  var parent = target.parentNode
+	  if (parent) {
+	    parent.replaceChild(el, target)
+	  }
+	}
+
+	/**
+	 * Copy attributes from one element to another.
+	 *
+	 * @param {Element} from
+	 * @param {Element} to
+	 */
+
+	exports.copyAttributes = function (from, to) {
+	  if (from.hasAttributes()) {
+	    var attrs = from.attributes
+	    for (var i = 0, l = attrs.length; i < l; i++) {
+	      var attr = attrs[i]
+	      to.setAttribute(attr.name, attr.value)
+	    }
+	  }
+	}
+
+	/**
+	 * Add event listener shorthand.
+	 *
+	 * @param {Element} el
+	 * @param {String} event
+	 * @param {Function} cb
+	 */
+
+	exports.on = function (el, event, cb) {
+	  el.addEventListener(event, cb)
+	}
+
+	/**
+	 * Remove event listener shorthand.
+	 *
+	 * @param {Element} el
+	 * @param {String} event
+	 * @param {Function} cb
+	 */
+
+	exports.off = function (el, event, cb) {
+	  el.removeEventListener(event, cb)
+	}
+
+	/**
+	 * Add class with compatibility for IE & SVG
+	 *
+	 * @param {Element} el
+	 * @param {Strong} cls
+	 */
+
+	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())
+	    }
+	  }
+	}
+
+	/**
+	 * Remove class with compatibility for IE & SVG
+	 *
+	 * @param {Element} el
+	 * @param {Strong} cls
+	 */
+
+	exports.removeClass = function (el, cls) {
+	  if (el.classList) {
+	    el.classList.remove(cls)
+	  } else {
+	    var cur = ' ' + (el.getAttribute('class') || '') + ' '
+	    var tar = ' ' + cls + ' '
+	    while (cur.indexOf(tar) >= 0) {
+	      cur = cur.replace(tar, ' ')
+	    }
+	    el.setAttribute('class', cur.trim())
+	  }
+	}
+
+/***/ },
+/* 17 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(18)
+
+	/**
+	 * 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.
+	 *
+	 * @param {Vue} vm
+	 * @param {Array<Object>} filters
+	 * @param {Object} [target]
+	 * @return {Object}
+	 */
+
+	exports.resolveFilters = function (vm, filters, target) {
+	  if (!filters) {
+	    return
+	  }
+	  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 {*}
+	 */
+
+	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)
+	  }
+	  return value
+	}
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var config = __webpack_require__(20)
+
+	/**
+	 * 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) {
+	      console.warn('[Vue warn]: ' + msg)
+	      if (config.debug && console.trace) {
+	        console.trace()
+	      }
+	    }
+	  }
+
+	  /**
+	   * Assert asset exists
+	   */
+
+	  exports.assertAsset = function (val, type, id) {
+	    if (!val) {
+	      exports.warn('Failed to resolve ' + type + ': ' + id)
+	    }
+	  }
+	}
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	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)
+
+	/**
+	 * Data
+	 */
+
+	strats.data = function (parentVal, childVal, vm) {
+	  // in a class merge, both should be functions
+	  // so we just return child if it exists
+	  if (!vm) {
+	    if (childVal && typeof childVal !== 'function') {
+	      _.warn(
+	        'The "data" option should be a function ' +
+	        'that returns a per-instance value in component ' +
+	        'definitions.'
+	      )
+	      return
+	    }
+	    return childVal || parentVal
+	  }
+	  var instanceData = typeof childVal === 'function'
+	    ? childVal.call(vm)
+	    : childVal
+	  var defaultData = typeof parentVal === 'function'
+	    ? parentVal.call(vm)
+	    : undefined
+	  if (instanceData) {
+	    // mix default data into instance data
+	    for (var key in defaultData) {
+	      if (!instanceData.hasOwnProperty(key)) {
+	        instanceData.$add(key, defaultData[key])
+	      }
+	    }
+	    return instanceData
+	  } else {
+	    return defaultData
+	  }
+	}
+
+	/**
+	 * El
+	 */
+
+	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
+	  }
+	  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.
+	 */
+
+	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
+	    while (i--) {
+	      field = keys[i]
+	      ret[field] = parentVal[field]
+	    }
+	  }
+	  if (childVal) extend(ret, childVal)
+	  return ret
+	}
+
+	/**
+	 * Events & Watchers.
+	 *
+	 * Events & watchers hashes should not overwrite one
+	 * another, so we merge them as arrays.
+	 */
+
+	strats.watch =
+	strats.events = function (parentVal, childVal) {
+	  if (!childVal) return parentVal
+	  if (!parentVal) return childVal
+	  var ret = {}
+	  extend(ret, parentVal)
+	  for (var key in childVal) {
+	    var parent = ret[key]
+	    var child = childVal[key]
+	    ret[key] = parent
+	      ? parent.concat(child)
+	      : [child]
+	  }
+	  return ret
+	}
+
+	/**
+	 * Other object hashes.
+	 */
+
+	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
+	}
+
+	/**
+	 * Default strategy.
+	 */
+
+	var defaultStrat = function (parentVal, childVal) {
+	  return childVal === undefined
+	    ? parentVal
+	    : childVal
+	}
+
+	/**
+	 * Make sure component options get converted to actual
+	 * constructors.
+	 *
+	 * @param {Object} components
+	 */
+
+	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)
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Merge two option objects into a new one.
+	 * Core utility used in both instantiation and inheritance.
+	 *
+	 * @param {Object} parent
+	 * @param {Object} child
+	 * @param {Vue} [vm] - if vm is present, indicates this is
+	 *                     an instantiation merge.
+	 */
+
+	module.exports = function mergeOptions (parent, child, vm) {
+	  guardComponents(child.components)
+	  var options = {}
+	  var key
+	  for (key in parent) {
+	    merge(parent[key], child[key], key)
+	  }
+	  for (key in child) {
+	    if (!(parent.hasOwnProperty(key))) {
+	      merge(parent[key], child[key], key)
+	    }
+	  }
+	  var mixins = child.mixins
+	  if (mixins) {
+	    for (var i = 0, l = mixins.length; i < l; i++) {
+	      for (key in mixins[i]) {
+	        merge(options[key], mixins[i][key], key)
+	      }
+	    }
+	  }
+	  function merge (parentVal, childVal, key) {
+	    var strat = strats[key] || defaultStrat
+	    options[key] = strat(parentVal, childVal, vm, key)
+	  }
+	  return options
+	}
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	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,
+
+	  /**
+	   * Internal flag to indicate the delimiters have been
+	   * changed.
+	   *
+	   * @type {Boolean}
+	   */
+
+	  _delimitersChanged: true
+
+	}
+
+	/**
+	 * Interpolation delimiters.
+	 * We need to mark the changed flag so that the text parser
+	 * knows it needs to recompile the regex.
+	 *
+	 * @type {Array<String>}
+	 */
+
+	var delimiters = ['{{', '}}']
+	Object.defineProperty(module.exports, 'delimiters', {
+	  get: function () {
+	    return delimiters
+	  },
+	  set: function (val) {
+	    delimiters = val
+	    this._delimitersChanged = true
+	  }
+	})
+
+/***/ },
+/* 21 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var config = __webpack_require__(20)
+	var Observer = __webpack_require__(49)
+	var expParser = __webpack_require__(44)
+	var Batcher = __webpack_require__(50)
+
+	var batcher = new Batcher()
+	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.
+	 *
+	 * @param {Vue} vm
+	 * @param {String} expression
+	 * @param {Function} cb
+	 * @param {Array} [filters]
+	 * @param {Boolean} [needSet]
+	 * @param {Boolean} [deep]
+	 * @constructor
+	 */
+
+	function Watcher (vm, expression, cb, filters, needSet, deep) {
+	  this.vm = vm
+	  vm._watcherList.push(this)
+	  this.expression = expression
+	  this.cbs = [cb]
+	  this.id = ++uid // uid for batching
+	  this.active = true
+	  this.deep = deep
+	  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.
+	  this.readFilters = filters && filters.read
+	  this.writeFilters = filters && filters.write
+	  // parse expression for getter/setter
+	  var res = expParser.parse(expression, needSet)
+	  this.getter = res.get
+	  this.setter = res.set
+	  this.value = this.get()
+	}
+
+	var p = Watcher.prototype
+
+	/**
+	 * Add a binding dependency to this directive.
+	 *
+	 * @param {Binding} binding
+	 */
+
+	p.addDep = function (binding) {
+	  var id = binding.id
+	  if (!this.newDeps[id]) {
+	    this.newDeps[id] = binding
+	    if (!this.deps[id]) {
+	      this.deps[id] = binding
+	      binding.addSub(this)
+	    }
+	  }
+	}
+
+	/**
+	 * Evaluate the getter, and re-collect dependencies.
+	 */
+
+	p.get = function () {
+	  this.beforeGet()
+	  var vm = this.vm
+	  var value
+	  try {
+	    value = this.getter.call(vm, vm)
+	  } catch (e) {}
+	  // use JSON.stringify to "touch" every property
+	  // so they are all tracked as dependencies for
+	  // deep watching
+	  if (this.deep) JSON.stringify(value)
+	  value = _.applyFilters(value, this.readFilters, vm)
+	  this.afterGet()
+	  return value
+	}
+
+	/**
+	 * Set the corresponding value with the setter.
+	 *
+	 * @param {*} value
+	 */
+
+	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) {}
+	}
+
+	/**
+	 * Prepare for dependency collection.
+	 */
+
+	p.beforeGet = function () {
+	  Observer.target = this
+	  this.newDeps = {}
+	}
+
+	/**
+	 * Clean up for dependency collection.
+	 */
+
+	p.afterGet = function () {
+	  Observer.target = null
+	  for (var id in this.deps) {
+	    if (!this.newDeps[id]) {
+	      this.deps[id].removeSub(this)
+	    }
+	  }
+	  this.deps = this.newDeps
+	}
+
+	/**
+	 * Subscriber interface.
+	 * Will be called when a dependency changes.
+	 */
+
+	p.update = function () {
+	  if (config.async) {
+	    batcher.push(this)
+	  } else {
+	    this.run()
+	  }
+	}
+
+	/**
+	 * Batcher job interface.
+	 * Will be called by the batcher.
+	 */
+
+	p.run = function () {
+	  if (this.active) {
+	    var value = this.get()
+	    if (
+	      (typeof value === 'object' && value !== null) ||
+	      value !== this.value
+	    ) {
+	      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
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * 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) {
+	    var i = cbs.indexOf(cb)
+	    if (i > -1) {
+	      cbs.splice(i, 1)
+	    }
+	  } else if (cb === cbs[0]) {
+	    this.teardown()
+	  }
+	}
+
+	/**
+	 * Remove self from all dependencies' subcriber list.
+	 */
+
+	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) {
+	      var list = this.vm._watcherList
+	      list.splice(list.indexOf(this))
+	    }
+	    for (var id in this.deps) {
+	      this.deps[id].removeSub(this)
+	    }
+	    this.active = false
+	    this.vm = this.cbs = this.value = null
+	  }
+	}
+
+	module.exports = Watcher
+
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	module.exports = {
+
+	  bind: function () {
+	    this.attr = this.el.nodeType === 3
+	      ? 'nodeValue'
+	      : 'textContent'
+	  },
+
+	  update: function (value) {
+	    this.el[this.attr] = _.toString(value)
+	  }
+	  
+	}
+
+/***/ },
+/* 23 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var templateParser = __webpack_require__(51)
+
+	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 = []
+	    }
+	  },
+
+	  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
+	    var frag = templateParser.parse(value, true)
+	    // save a reference to these nodes so we can remove later
+	    this.nodes = _.toArray(frag.childNodes)
+	    _.before(frag, this.el)
+	  }
+
+	}
+
+/***/ },
+/* 24 */
+/***/ 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')
+	  }
+	}
+
+/***/ },
+/* 25 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var transition = __webpack_require__(45)
+
+	module.exports = function (value) {
+	  var el = this.el
+	  transition.apply(el, value ? 1 : -1, function () {
+	    el.style.display = value ? '' : 'none'
+	  }, this.vm)
+	}
+
+/***/ },
+/* 26 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	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
+	    }
+	  }
+	}
+
+/***/ },
+/* 27 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = {
+
+	  isLiteral: true,
+
+	  bind: function () {
+	    this.vm.$$[this.expression] = this.el
+	  },
+
+	  unbind: function () {
+	    delete this.vm.$$[this.expression]
+	  }
+	  
+	}
+
+/***/ },
+/* 28 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	module.exports = {
+
+	  isLiteral: true,
+
+	  bind: function () {
+	    if (this.el !== this.vm.$el) {
+	      _.warn(
+	        'v-ref should only be used on instance root nodes.'
+	      )
+	      return
+	    }
+	    this.owner = this.vm.$parent
+	    this.owner.$[this.expression] = this.vm
+	  },
+
+	  unbind: function () {
+	    if (this.owner.$[this.expression] === this.vm) {
+	      delete this.owner.$[this.expression]
+	    }
+	  }
+	  
+	}
+
+/***/ },
+/* 29 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var config = __webpack_require__(20)
+
+	module.exports = {
+
+	  bind: function () {
+	    var el = this.el
+	    this.vm.$once('hook:compiled', function () {
+	      el.removeAttribute(config.prefix + 'cloak')
+	    })
+	  }
+
+	}
+
+/***/ },
+/* 30 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var prefixes = ['-webkit-', '-moz-', '-ms-']
+	var importantRE = /!important;?$/
+
+	module.exports = {
+
+	  bind: function () {
+	    var prop = this.arg
+	    if (!prop) return
+	    if (prop.charAt(0) === '$') {
+	      // properties that start with $ will be auto-prefixed
+	      prop = prop.slice(1)
+	      this.prefixed = true
+	    }
+	    this.prop = prop
+	  },
+
+	  update: function (value) {
+	    var prop = this.prop
+	    // cast possible numbers/booleans into strings
+	    if (value != null) {
+	      value += ''
+	    }
+	    if (prop) {
+	      var isImportant = importantRE.test(value)
+	        ? 'important'
+	        : ''
+	      if (isImportant) {
+	        value = value.replace(importantRE, '').trim()
+	      }
+	      this.el.style.setProperty(prop, value, isImportant)
+	      if (this.prefixed) {
+	        var i = prefixes.length
+	        while (i--) {
+	          this.el.style.setProperty(
+	            prefixes[i] + prop,
+	            value,
+	            isImportant
+	          )
+	        }
+	      }
+	    } else {
+	      this.el.style.cssText = value
+	    }
+	  }
+
+	}
+
+/***/ },
+/* 31 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var templateParser = __webpack_require__(51)
+	var transition = __webpack_require__(45)
+
+	module.exports = {
+
+	  isLiteral: true,
+
+	  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.compile(this.expression)
+	    }
+	  },
+
+	  update: function (id) {
+	    this.teardown()
+	    this.compile(id)
+	  },
+
+	  compile: function (id) {
+	    var partial = this.vm.$options.partials[id]
+	    _.assertAsset(partial, 'partial', id)
+	    if (!partial) {
+	      return
+	    }
+	    var vm = this.vm
+	    var frag = templateParser.parse(partial, true)
+	    var decompile = vm.$compile(frag)
+	    this.decompile = function () {
+	      decompile()
+	      transition.blockRemove(this.start, this.end, vm)
+	    }
+	    transition.blockAppend(frag, this.end, vm)
+	  },
+
+	  teardown: function () {
+	    if (this.decompile) {
+	      this.decompile()
+	      this.decompile = null
+	    }
+	  }
+
+	}
+
+/***/ },
+/* 32 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = {
+
+	  priority: 1000,
+	  isLiteral: true,
+
+	  bind: function () {
+	    this.el.__v_trans = {
+	      id: this.expression
+	    }
+	  }
+
+	}
+
+/***/ },
+/* 33 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	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)
+	  }
+	}
+
+/***/ },
+/* 34 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var templateParser = __webpack_require__(51)
+
+	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
+	      this.checkKeepAlive()
+	      // check parent directives
+	      this.parentLinker = this.el._parentLinker
+	      // if static, build right now.
+	      if (!this._isDynamicLiteral) {
+	        this.resolveCtor(this.expression)
+	        this.build()
+	      }
+	    } else {
+	      _.warn(
+	        'v-component="' + this.expression + '" cannot be ' +
+	        'used on an already mounted instance.'
+	      )
+	    }
+	  },
+
+	  /**
+	   * Check if the "keep-alive" flag is present.
+	   * 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.
+	   */
+
+	  checkKeepAlive: function () {
+	    // check keep-alive flag
+	    this.keepAlive = this.el.hasAttribute('keep-alive')
+	    if (this.keepAlive) {
+	      this.el.removeAttribute('keep-alive')
+	      this.cache = {}
+	    }
+	  },
+
+	  /**
+	   * Resolve the component constructor to use when creating
+	   * the child vm.
+	   */
+
+	  resolveCtor: function (id) {
+	    this.ctorId = id
+	    this.Ctor = this.vm.$options.components[id]
+	    _.assertAsset(this.Ctor, 'component', id)
+	  },
+
+	  /**
+	   * Instantiate/insert a new child vm.
+	   * If keep alive and has cached instance, insert that
+	   * instance; otherwise build a new one and cache it.
+	   */
+
+	  build: function () {
+	    if (this.keepAlive) {
+	      var cached = this.cache[this.ctorId]
+	      if (cached) {
+	        this.childVM = cached
+	        cached.$before(this.ref)
+	        return
+	      }
+	    }
+	    var vm = this.vm
+	    if (this.Ctor && !this.childVM) {
+	      this.childVM = vm.$addChild({
+	        el: templateParser.clone(this.el)
+	      }, this.Ctor)
+	      if (this.parentLinker) {
+	        var dirCount = vm._directives.length
+	        var targetVM = this.childVM.$options.inherit
+	          ? this.childVM
+	          : vm
+	        this.parentLinker(targetVM, this.childVM.$el)
+	        this.parentDirs = vm._directives.slice(dirCount)
+	      }
+	      if (this.keepAlive) {
+	        this.cache[this.ctorId] = this.childVM
+	      }
+	      this.childVM.$before(this.ref)
+	    }
+	  },
+
+	  /**
+	   * Teardown the active vm.
+	   * If keep alive, simply remove it; otherwise destroy it.
+	   *
+	   * @param {Boolean} remove
+	   */
+
+	  unbuild: function (remove) {
+	    var child = this.childVM
+	    if (!child) {
+	      return
+	    }
+	    if (this.keepAlive) {
+	      if (remove) {
+	        child.$remove()
+	      }
+	    } else {
+	      child.$destroy(remove)
+	      var parentDirs = this.parentDirs
+	      if (parentDirs) {
+	        var i = parentDirs.length
+	        while (i--) {
+	          parentDirs[i]._teardown()
+	        }
+	      }
+	    }
+	    this.childVM = null
+	  },
+
+	  /**
+	   * Update callback for the dynamic literal scenario,
+	   * e.g. v-component="{{view}}"
+	   */
+
+	  update: function (value) {
+	    this.unbuild(true)
+	    if (value) {
+	      this.resolveCtor(value)
+	      this.build()
+	    }
+	  },
+
+	  /**
+	   * Unbind.
+	   * Make sure keepAlive is set to false so that the
+	   * instance is always destroyed.
+	   */
+
+	  unbind: function () {
+	    this.keepAlive = false
+	    this.unbuild()
+	  }
+
+	}
+
+/***/ },
+/* 35 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var isObject = _.isObject
+	var textParser = __webpack_require__(42)
+	var expParser = __webpack_require__(44)
+	var templateParser = __webpack_require__(51)
+	var compile = __webpack_require__(46)
+	var transclude = __webpack_require__(47)
+	var mergeOptions = __webpack_require__(19)
+	var uid = 0
+
+	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.
+	    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)
+	    // check if this is a block repeat
+	    this.template = this.el.tagName === 'TEMPLATE'
+	      ? templateParser.parse(this.el, true)
+	      : this.el
+	    // check other directives that need to be handled
+	    // at v-repeat level
+	    this.checkIf()
+	    this.checkRef()
+	    this.checkTrackById()
+	    this.checkComponent()
+	    // cache for primitive value instances
+	    this.cache = Object.create(null)
+	  },
+
+	  /**
+	   * Warn against v-if usage.
+	   */
+
+	  checkIf: function () {
+	    if (_.attr(this.el, 'if') !== null) {
+	      _.warn(
+	        'Don\'t use v-if with v-repeat. ' +
+	        'Use v-show or the "filterBy" filter instead.'
+	      )
+	    }
+	  },
+
+	  /**
+	   * Check if v-ref/ v-el is also present.
+	   */
+
+	  checkRef: function () {
+	    var childId = _.attr(this.el, 'ref')
+	    this.childId = childId
+	      ? this.vm.$interpolate(childId)
+	      : null
+	    var elId = _.attr(this.el, 'el')
+	    this.elId = elId
+	      ? this.vm.$interpolate(elId)
+	      : null
+	  },
+
+	  /**
+	   * Check for a track-by ID, which allows us to identify
+	   * a piece of data and its associated instance by its
+	   * unique id.
+	   */
+
+	  checkTrackById: function () {
+	    this.idKey = this.el.getAttribute('trackby')
+	    if (this.idKey !== null) {
+	      this.el.removeAttribute('trackby')
+	    }
+	  },
+
+	  /**
+	   * 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')
+	    var options = this.vm.$options
+	    if (!id) {
+	      this.Ctor = _.Vue // default constructor
+	      this.inherit = true // inline repeats should inherit
+	      // important: transclude with no options, just
+	      // to ensure block start and block end
+	      this.template = transclude(this.template)
+	      this._linker = compile(this.template, options)
+	    } else {
+	      var tokens = textParser.parse(id)
+	      if (!tokens) { // static component
+	        var Ctor = this.Ctor = options.components[id]
+	        _.assertAsset(Ctor, 'component', id)
+	        if (Ctor) {
+	          // merge an empty object with owner vm as parent
+	          // so child vms can access parent assets.
+	          var merged = mergeOptions(
+	            Ctor.options,
+	            {},
+	            { $parent: this.vm }
+	          )
+	          this.template = transclude(this.template, merged)
+	          this._linker = compile(this.template, merged)
+	        }
+	      } else {
+	        // to be resolved later
+	        var ctorExp = textParser.tokensToExp(tokens)
+	        this.ctorGetter = expParser.parse(ctorExp).get
+	      }
+	    }
+	  },
+
+	  /**
+	   * Update.
+	   * This is called whenever the Array mutates.
+	   *
+	   * @param {Array} data
+	   */
+
+	  update: function (data) {
+	    if (typeof data === 'number') {
+	      data = range(data)
+	    }
+	    this.vms = this.diff(data || [], this.vms)
+	    // update v-ref
+	    if (this.childId) {
+	      this.vm.$[this.childId] = this.vms
+	    }
+	    if (this.elId) {
+	      this.vm.$$[this.elId] = this.vms.map(function (vm) {
+	        return vm.$el
+	      })
+	    }
+	  },
+
+	  /**
+	   * Diff, based on new data and old data, determine the
+	   * minimum amount of DOM manipulations needed to make the
+	   * DOM reflect the new data Array.
+	   *
+	   * The algorithm diffs the new data Array by storing a
+	   * hidden reference to an owner vm instance on previously
+	   * seen data. This allows us to achieve O(n) which is
+	   * better than a levenshtein distance based algorithm,
+	   * which is O(m * n).
+	   *
+	   * @param {Array} data
+	   * @param {Array} oldVms
+	   * @return {Array}
+	   */
+
+	  diff: function (data, oldVms) {
+	    var idKey = this.idKey
+	    var converted = this.converted
+	    var ref = this.ref
+	    var alias = this.arg
+	    var init = !oldVms
+	    var vms = new Array(data.length)
+	    var obj, raw, vm, i, l
+	    // First pass, go through the new Array and fill up
+	    // the new vms array. If a piece of data has a cached
+	    // instance for it, we reuse it. Otherwise build a new
+	    // instance.
+	    for (i = 0, l = data.length; i < l; i++) {
+	      obj = data[i]
+	      raw = converted ? obj.value : obj
+	      vm = !init && this.getVm(raw)
+	      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
+	          if (alias) {
+	            vm[alias] = raw
+	          } else {
+	            vm._setData(raw)
+	          }
+	        }
+	      } else { // new instance
+	        vm = this.build(obj, i)
+	        vm._new = true
+	      }
+	      vms[i] = vm
+	      // insert if this is first run
+	      if (init) {
+	        vm.$before(ref)
+	      }
+	    }
+	    // if this is the first run, we're done.
+	    if (init) {
+	      return vms
+	    }
+	    // Second pass, go through the old vm instances and
+	    // destroy those who are not reused (and remove them
+	    // from cache)
+	    for (i = 0, l = oldVms.length; i < l; i++) {
+	      vm = oldVms[i]
+	      if (!vm._reused) {
+	        this.uncacheVm(vm)
+	        vm.$destroy(true)
+	      }
+	    }
+	    // final pass, move/insert new instances into the
+	    // right place. We're going in reverse here because
+	    // insertBefore relies on the next sibling to be
+	    // resolved.
+	    var targetNext, currentNext
+	    i = vms.length
+	    while (i--) {
+	      vm = vms[i]
+	      // this is the vm that we should be in front of
+	      targetNext = vms[i + 1]
+	      if (!targetNext) {
+	        // This is the last item. If it's reused then
+	        // everything else will eventually be in the right
+	        // place, so no need to touch it. Otherwise, insert
+	        // it.
+	        if (!vm._reused) {
+	          vm.$before(ref)
+	        }
+	      } else {
+	        if (vm._reused) {
+	          // this is the vm we are actually in front of
+	          currentNext = findNextVm(vm, ref)
+	          // we only need to move if we are not in the right
+	          // place already.
+	          if (currentNext !== targetNext) {
+	            vm.$before(targetNext.$el, null, false)
+	          }
+	        } else {
+	          // new instance, insert to existing next
+	          vm.$before(targetNext.$el)
+	        }
+	      }
+	      vm._new = false
+	      vm._reused = false
+	    }
+	    return vms
+	  },
+
+	  /**
+	   * Build a new instance and cache it.
+	   *
+	   * @param {Object} data
+	   * @param {Number} index
+	   */
+
+	  build: function (data, index) {
+	    var original = data
+	    var meta = { $index: index }
+	    if (this.converted) {
+	      meta.$key = original.key
+	    }
+	    var raw = this.converted ? data.value : data
+	    var alias = this.arg
+	    var hasAlias = !isObject(raw) || alias
+	    // wrap the raw data with alias
+	    data = hasAlias ? {} : raw
+	    if (alias) {
+	      data[alias] = raw
+	    } else if (hasAlias) {
+	      meta.$value = raw
+	    }
+	    // resolve constructor
+	    var Ctor = this.Ctor || this.resolveCtor(data, meta)
+	    var vm = this.vm.$addChild({
+	      el: templateParser.clone(this.template),
+	      _linker: this._linker,
+	      _meta: meta,
+	      data: data,
+	      inherit: this.inherit
+	    }, Ctor)
+	    // cache instance
+	    this.cacheVm(raw, vm)
+	    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])
+	    }
+	    for (key in meta) {
+	      _.define(context, key, meta[key])
+	    }
+	    var id = this.ctorGetter.call(context, context)
+	    var Ctor = this.vm.$options.components[id]
+	    _.assertAsset(Ctor, 'component', id)
+	    return Ctor
+	  },
+
+	  /**
+	   * Unbind, teardown everything
+	   */
+
+	  unbind: function () {
+	    if (this.childId) {
+	      delete this.vm.$[this.childId]
+	    }
+	    if (this.vms) {
+	      var i = this.vms.length
+	      var vm
+	      while (i--) {
+	        vm = this.vms[i]
+	        this.uncacheVm(vm)
+	        vm.$destroy()
+	      }
+	    }
+	  },
+
+	  /**
+	   * Cache a vm instance based on its data.
+	   *
+	   * If the data is an object, we save the vm's reference on
+	   * the data object as a hidden property. Otherwise we
+	   * cache them in an object and for each primitive value
+	   * there is an array in case there are duplicates.
+	   *
+	   * @param {Object} data
+	   * @param {Vue} vm
+	   */
+
+	  cacheVm: function (data, vm) {
+	    var idKey = this.idKey
+	    var cache = this.cache
+	    var id
+	    if (idKey) {
+	      id = data[idKey]
+	      if (!cache[id]) {
+	        cache[id] = vm
+	      } else {
+	        _.warn('Duplicate ID in v-repeat: ' + id)
+	      }
+	    } else if (isObject(data)) {
+	      id = this.id
+	      if (data.hasOwnProperty(id)) {
+	        if (data[id] === null) {
+	          data[id] = vm
+	        } else {
+	          _.warn(
+	            'Duplicate objects are not supported in v-repeat.'
+	          )
+	        }
+	      } else {
+	        _.define(data, this.id, vm)
+	      }
+	    } else {
+	      if (!cache[data]) {
+	        cache[data] = [vm]
+	      } else {
+	        cache[data].push(vm)
+	      }
+	    }
+	    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]
+	    } 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
+	    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()
+	    }
+	  }
+
+	}
+
+	/**
+	 * 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 {CommentNode} ref
+	 * @return {Vue}
+	 */
+
+	function findNextVm (vm, ref) {
+	  var el = (vm._blockEnd || vm.$el).nextSibling
+	  while (!el.__vue__ && el !== ref) {
+	    el = el.nextSibling
+	  }
+	  return el.__vue__
+	}
+
+	/**
+	 * 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.
+	 *
+	 * @param {*} obj
+	 * @return {Array}
+	 * @private
+	 */
+
+	function objToArray (obj) {
+	  if (!_.isPlainObject(obj)) {
+	    return obj
+	  }
+	  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]
+	    }
+	  }
+	  // `this` points to the repeat directive instance
+	  this.converted = true
+	  return res
+	}
+
+	/**
+	 * 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
+	}
+
+/***/ },
+/* 36 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var compile = __webpack_require__(46)
+	var templateParser = __webpack_require__(51)
+	var transition = __webpack_require__(45)
+
+	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(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) {
+	      this.insert()
+	    } else {
+	      this.teardown()
+	    }
+	  },
+
+	  insert: function () {
+	    // avoid duplicate inserts, since update() can be
+	    // called with different truthy values
+	    if (this.decompile) {
+	      return
+	    }
+	    var vm = this.vm
+	    var frag = templateParser.clone(this.template)
+	    var decompile = this.linker(vm, frag)
+	    this.decompile = function () {
+	      decompile()
+	      transition.blockRemove(this.start, this.end, vm)
+	    }
+	    transition.blockAppend(frag, this.end, vm)
+	  },
+
+	  teardown: function () {
+	    if (this.decompile) {
+	      this.decompile()
+	      this.decompile = null
+	    }
+	  }
+
+	}
+
+/***/ },
+/* 37 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var Watcher = __webpack_require__(21)
+
+	module.exports = {
+
+	  priority: 900,
+
+	  bind: function () {
+	    var vm = this.vm
+	    if (this.el !== vm.$el) {
+	      _.warn(
+	        'v-with can only be used on instance root elements.'
+	      )
+	    } else if (!vm.$parent) {
+	      _.warn(
+	        'v-with must be used on an instance with a parent.'
+	      )
+	    } else {
+	      var key = this.arg
+	      this.watcher = new Watcher(
+	        vm.$parent,
+	        this.expression,
+	        key
+	          ? function (val) {
+	              vm.$set(key, val)
+	            }
+	          : function (val) {
+	              vm.$data = val
+	            }
+	      )
+	      // initial set
+	      var initialVal = this.watcher.value
+	      if (key) {
+	        vm.$set(key, initialVal)
+	      } else {
+	        vm.$data = initialVal
+	      }
+	    }
+	  },
+
+	  unbind: function () {
+	    if (this.watcher) {
+	      this.watcher.teardown()
+	    }
+	  }
+
+	}
+
+/***/ },
+/* 38 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var Path = __webpack_require__(41)
+
+	/**
+	 * Filter filter for v-repeat
+	 *
+	 * @param {String} searchKey
+	 * @param {String} [delimiter]
+	 * @param {String} dataKey
+	 */
+
+	exports.filterBy = function (arr, searchKey, delimiter, dataKey) {
+	  // allow optional `in` delimiter
+	  // because why not
+	  if (delimiter && delimiter !== 'in') {
+	    dataKey = delimiter
+	  }
+	  // get the search string
+	  var search =
+	    _.stripQuotes(searchKey) ||
+	    this.$get(searchKey)
+	  if (!search) {
+	    return arr
+	  }
+	  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)
+	  })
+	}
+
+	/**
+	 * Filter filter for v-repeat
+	 *
+	 * @param {String} sortKey
+	 * @param {String} reverseKey
+	 */
+
+	exports.orderBy = function (arr, sortKey, reverseKey) {
+	  var key =
+	    _.stripQuotes(sortKey) ||
+	    this.$get(sortKey)
+	  if (!key) {
+	    return arr
+	  }
+	  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
+	    }
+	  }
+	  // sort on a copy to avoid mutating original array
+	  return arr.slice().sort(function (a, b) {
+	    a = Path.get(a, key)
+	    b = Path.get(b, key)
+	    return a === b ? 0 : a > b ? order : -order
+	  })
+	}
+
+	/**
+	 * String contain helper
+	 *
+	 * @param {*} val
+	 * @param {String} search
+	 */
+
+	function contains (val, search) {
+	  if (_.isObject(val)) {
+	    for (var key in val) {
+	      if (contains(val[key], search)) {
+	        return true
+	      }
+	    }
+	  } else if (val != null) {
+	    return val.toString().toLowerCase().indexOf(search) > -1
+	  }
+	}
+
+/***/ },
+/* 39 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var uid = 0
+
+	/**
+	 * A binding is an observable that can have multiple
+	 * directives subscribing to it.
+	 *
+	 * @constructor
+	 */
+
+	function Binding () {
+	  this.id = ++uid
+	  this.subs = []
+	}
+
+	var p = Binding.prototype
+
+	/**
+	 * Add a directive subscriber.
+	 *
+	 * @param {Directive} sub
+	 */
+
+	p.addSub = function (sub) {
+	  this.subs.push(sub)
+	}
+
+	/**
+	 * Remove a directive subscriber.
+	 *
+	 * @param {Directive} sub
+	 */
+
+	p.removeSub = function (sub) {
+	  if (this.subs.length) {
+	    var i = this.subs.indexOf(sub)
+	    if (i > -1) this.subs.splice(i, 1)
+	  }
+	}
+
+	/**
+	 * Notify all subscribers of a new value.
+	 */
+
+	p.notify = function () {
+	  for (var i = 0, l = this.subs.length; i < l; i++) {
+	    this.subs[i].update()
+	  }
+	}
+
+	module.exports = Binding
+
+/***/ },
+/* 40 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var config = __webpack_require__(20)
+	var Watcher = __webpack_require__(21)
+	var textParser = __webpack_require__(42)
+	var expParser = __webpack_require__(44)
+
+	/**
+	 * 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 {Function} [linker] - pre-compiled linker function
+	 * @constructor
+	 */
+
+	function Directive (name, el, vm, descriptor, def, linker) {
+	  // 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._linker = linker
+	  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.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.update && this._watcherExp &&
+	    (!this.isLiteral || this._isDynamicLiteral) &&
+	    !this._checkStatement()
+	  ) {
+	    // use raw expression as identifier because filters
+	    // make them different watchers
+	    var watcher = this.vm._watchers[this.raw]
+	    // wrapped updater for context
+	    var dir = this
+	    var update = this._update = function (val, oldVal) {
+	      if (!dir._locked) {
+	        dir.update(val, oldVal)
+	      }
+	    }
+	    if (!watcher) {
+	      watcher = this.vm._watchers[this.raw] = new Watcher(
+	        this.vm,
+	        this._watcherExp,
+	        update, // callback
+	        this.filters,
+	        this.twoWay // need setter
+	      )
+	    } else {
+	      watcher.addCb(update)
+	    }
+	    this._watcher = watcher
+	    if (this._initValue != null) {
+	      watcher.set(this._initValue)
+	    } else {
+	      this.update(watcher.value)
+	    }
+	  }
+	  this._bound = true
+	}
+
+	/**
+	 * check if this is a dynamic literal binding.
+	 *
+	 * e.g. v-component="{{currentView}}"
+	 */
+
+	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
+	    }
+	  }
+	}
+
+	/**
+	 * 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++"
+	 *
+	 * @return {Boolean}
+	 */
+
+	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
+	      )
+	    }
+	    this.update(handler)
+	    return true
+	  }
+	}
+
+	/**
+	 * Teardown the watcher and call unbind.
+	 */
+
+	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
+	      }
+	    }
+	    this._bound = false
+	    this.vm = this.el = this._watcher = null
+	  }
+	}
+
+	/**
+	 * Set the corresponding value with the setter.
+	 * This should only be used in two-way directives
+	 * e.g. v-model.
+	 *
+	 * @param {*} value
+	 * @param {Boolean} lock - prevent wrtie triggering update.
+	 * @public
+	 */
+
+	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        
+	      })
+	    }
+	  }
+	}
+
+	module.exports = Directive
+
+/***/ },
+/* 41 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var Cache = __webpack_require__(52)
+	var pathCache = new Cache(1000)
+	var identRE = /^[$_a-zA-Z]+[\w$]*$/
+
+	/**
+	 * Path-parsing algorithm scooped from Polymer/observe-js
+	 */
+
+	var pathStateMachine = {
+	  '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']
+	  }
+	}
+
+	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: // ]
+	    case 0x2E: // .
+	    case 0x22: // "
+	    case 0x27: // '
+	    case 0x30: // 0
+	      return char
+
+	    case 0x5F: // _
+	    case 0x24: // $
+	      return 'ident'
+
+	    case 0x20: // Space
+	    case 0x09: // Tab
+	    case 0x0A: // Newline
+	    case 0x0D: // Return
+	    case 0xA0:  // No-break space
+	    case 0xFEFF:  // Byte Order Mark
+	    case 0x2028:  // Line Separator
+	    case 0x2029:  // Paragraph Separator
+	      return 'ws'
+	  }
+
+	  // a-z, A-Z
+	  if ((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
+	 *
+	 * @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) {
+	        return
+	      }
+	      keys.push(key)
+	      key = undefined
+	    },
+	    append: function() {
+	      if (key === undefined) {
+	        key = newChar
+	      } else {
+	        key += newChar
+	      }
+	    }
+	  }
+
+	  function maybeUnescapeQuote () {
+	    var nextChar = path[index + 1]
+	    if ((mode === 'inSingleQuote' && nextChar === "'") ||
+	        (mode === 'inDoubleQuote' && nextChar === '"')) {
+	      index++
+	      newChar = nextChar
+	      actions.append()
+	      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
+	      ? c
+	      : transition[2]
+	    action()
+
+	    if (mode === 'afterPath') {
+	      return keys
+	    }
+	  }
+	}
+
+	/**
+	 * Format a accessor segment based on its type.
+	 *
+	 * @param {String} key
+	 * @return {Boolean}
+	 */
+
+	function formatAccessor(key) {
+	  if (identRE.test(key)) { // identifier
+	    return '.' + key
+	  } else if (+key === key >>> 0) { // bracket index
+	    return '[' + key + ']';
+	  } else { // bracket string
+	    return '["' + key.replace(/"/g, '\\"') + '"]';
+	  }
+	}
+
+	/**
+	 * Compiles a getter function with a fixed path.
+	 *
+	 * @param {Array} path
+	 * @return {Function}
+	 */
+
+	exports.compileGetter = function (path) {
+	  var body =
+	    'try{return o' +
+	    path.map(formatAccessor).join('') +
+	    '}catch(e){};'
+	  return new Function('o', body)
+	}
+
+	/**
+	 * 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) {
+	    hit = parsePath(path)
+	    if (hit) {
+	      hit.get = exports.compileGetter(hit)
+	      pathCache.put(path, hit)
+	    }
+	  }
+	  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
+	 *
+	 * @param {Object} obj
+	 * @param {String | Array} path
+	 * @param {*} val
+	 */
+
+	exports.set = function (obj, path, val) {
+	  if (typeof path === 'string') {
+	    path = exports.parse(path)
+	  }
+	  if (!path || !_.isObject(obj)) {
+	    return false
+	  }
+	  var last, key
+	  for (var i = 0, l = path.length - 1; i < l; i++) {
+	    last = obj
+	    key = path[i]
+	    obj = obj[key]
+	    if (!_.isObject(obj)) {
+	      obj = {}
+	      last.$add(key, obj)
+	    }
+	  }
+	  key = path[i]
+	  if (key in obj) {
+	    obj[key] = val
+	  } else {
+	    obj.$add(key, val)
+	  }
+	  return true
+	}
+
+/***/ },
+/* 42 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var Cache = __webpack_require__(52)
+	var config = __webpack_require__(20)
+	var dirParser = __webpack_require__(43)
+	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]
+	  var close = config.delimiters[1]
+	  firstChar = open.charAt(0)
+	  lastChar = close.charAt(close.length - 1)
+	  var firstCharRE = escapeRegex(firstChar)
+	  var lastCharRE = escapeRegex(lastChar)
+	  var openRE = escapeRegex(open)
+	  var closeRE = escapeRegex(close)
+	  tagRE = new RegExp(
+	    firstCharRE + '?' + openRE +
+	    '(.+?)' +
+	    closeRE + lastCharRE + '?',
+	    'g'
+	  )
+	  htmlRE = new RegExp(
+	    '^' + firstCharRE + openRE +
+	    '.*' +
+	    closeRE + lastCharRE + '$'
+	  )
+	  // reset cache
+	  cache = new Cache(1000)
+	}
+
+	/**
+	 * Parse a template text string into an array of tokens.
+	 *
+	 * @param {String} text
+	 * @return {Array<Object> | null}
+	 *               - {String} type
+	 *               - {String} value
+	 *               - {Boolean} [html]
+	 *               - {Boolean} [oneTime]
+	 */
+
+	exports.parse = function (text) {
+	  if (config._delimitersChanged) {
+	    compileRegex()
+	  }
+	  var hit = cache.get(text)
+	  if (hit) {
+	    return hit
+	  }
+	  if (!tagRE.test(text)) {
+	    return null
+	  }
+	  var tokens = []
+	  var lastIndex = tagRE.lastIndex = 0
+	  var match, index, value, first, oneTime, partial
+	  /* jshint boss:true */
+	  while (match = tagRE.exec(text)) {
+	    index = match.index
+	    // push text token
+	    if (index > lastIndex) {
+	      tokens.push({
+	        value: text.slice(lastIndex, index)
+	      })
+	    }
+	    // tag token
+	    first = match[1].charCodeAt(0)
+	    oneTime = first === 0x2A // *
+	    partial = first === 0x3E // >
+	    value = (oneTime || partial)
+	      ? match[1].slice(1)
+	      : match[1]
+	    tokens.push({
+	      tag: true,
+	      value: value.trim(),
+	      html: htmlRE.test(match[0]),
+	      oneTime: oneTime,
+	      partial: partial
+	    })
+	    lastIndex = index + match[0].length
+	  }
+	  if (lastIndex < text.length) {
+	    tokens.push({
+	      value: text.slice(lastIndex)
+	    })
+	  }
+	  cache.put(text, tokens)
+	  return tokens
+	}
+
+	/**
+	 * Format a list of tokens into an expression.
+	 * e.g. tokens parsed from 'a {{b}} c' can be serialized
+	 * into one single expression as '"a " + b + " c"'.
+	 *
+	 * @param {Array} tokens
+	 * @param {Vue} [vm]
+	 * @return {String}
+	 */
+
+	exports.tokensToExp = function (tokens, vm) {
+	  return tokens.length > 1
+	    ? tokens.map(function (token) {
+	        return formatToken(token, vm)
+	      }).join('+')
+	    : formatToken(tokens[0], vm, true)
+	}
+
+	/**
+	 * Format a single token.
+	 *
+	 * @param {Object} token
+	 * @param {Vue} [vm]
+	 * @param {Boolean} single
+	 * @return {String}
+	 */
+
+	function formatToken (token, vm, single) {
+	  return token.tag
+	    ? vm && token.oneTime
+	      ? '"' + vm.$eval(token.value) + '"'
+	      : single
+	        ? token.value
+	        : inlineFilters(token.value)
+	    : '"' + token.value + '"'
+	}
+
+	/**
+	 * For an attribute with multiple interpolation tags,
+	 * e.g. attr="some-{{thing | filter}}", in order to combine
+	 * the whole thing into a single watchable expression, we
+	 * have to inline those filters. This function does exactly
+	 * that. This is a bit hacky but it avoids heavy changes
+	 * to directive parser and watcher mechanism.
+	 *
+	 * @param {String} exp
+	 * @return {String}
+	 */
+
+	var filterRE = /[^|]\|[^|]/
+	function inlineFilters (exp) {
+	  if (!filterRE.test(exp)) {
+	    return '(' + 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('","') + '"'
+	          : ''
+	        exp = 'this.$options.filters["' + filter.name + '"]' +
+	          '.apply(this,[' + exp + args + '])'
+	      }
+	      return exp
+	    }
+	  }
+	}
+
+/***/ },
+/* 43 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var Cache = __webpack_require__(52)
+	var cache = new Cache(1000)
+	var argRE = /^[^\{\?]+$|^'[^']*'$|^"[^"]*"$/
+	var filterTokenRE = /[^\s'"]+|'[^']+'|"[^"]+"/g
+
+	/**
+	 * Parser state
+	 */
+
+	var str
+	var c, i, l
+	var inSingle
+	var inDouble
+	var curly
+	var square
+	var paren
+	var begin
+	var argIndex
+	var dirs
+	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) {
+	    dir.expression = str.slice(argIndex, i).trim()
+	  } else if (lastFilterIndex !== begin) {
+	    pushFilter()
+	  }
+	  if (i === 0 || dir.expression) {
+	    dirs.push(dir)
+	  }
+	}
+
+	/**
+	 * Push a filter to the current directive object
+	 */
+
+	function pushFilter () {
+	  var exp = str.slice(lastFilterIndex, i).trim()
+	  var filter
+	  if (exp) {
+	    filter = {}
+	    var tokens = exp.match(filterTokenRE)
+	    filter.name = tokens[0]
+	    filter.args = tokens.length > 1 ? tokens.slice(1) : null
+	  }
+	  if (filter) {
+	    (dir.filters = dir.filters || []).push(filter)
+	  }
+	  lastFilterIndex = i + 1
+	}
+
+	/**
+	 * Parse a directive string into an Array of AST-like
+	 * objects representing directives.
+	 *
+	 * Example:
+	 *
+	 * "click: a = a + 1 | uppercase" will yield:
+	 * {
+	 *   arg: 'click',
+	 *   expression: 'a = a + 1',
+	 *   filters: [
+	 *     { name: 'uppercase', args: null }
+	 *   ]
+	 * }
+	 *
+	 * @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
+	  curly = square = paren = begin = argIndex = 0
+	  lastFilterIndex = 0
+	  dirs = []
+	  dir = {}
+	  arg = null
+
+	  for (i = 0, l = str.length; i < l; i++) {
+	    c = str.charCodeAt(i)
+	    if (inSingle) {
+	      // check single quote
+	      if (c === 0x27) inSingle = !inSingle
+	    } else if (inDouble) {
+	      // check double quote
+	      if (c === 0x22) inDouble = !inDouble
+	    } else if (
+	      c === 0x2C && // comma
+	      !paren && !curly && !square
+	    ) {
+	      // reached the end of a directive
+	      pushDir()
+	      // reset & skip the comma
+	      dir = {}
+	      begin = argIndex = lastFilterIndex = i + 1
+	    } else if (
+	      c === 0x3A && // colon
+	      !dir.expression &&
+	      !dir.arg
+	    ) {
+	      // argument
+	      arg = str.slice(begin, i).trim()
+	      // test for valid argument here
+	      // since we may have caught stuff like first half of
+	      // an object literal or a ternary expression.
+	      if (argRE.test(arg)) {
+	        argIndex = i + 1
+	        dir.arg = _.stripQuotes(arg) || arg
+	      }
+	    } else if (
+	      c === 0x7C && // pipe
+	      str.charCodeAt(i + 1) !== 0x7C &&
+	      str.charCodeAt(i - 1) !== 0x7C
+	    ) {
+	      if (dir.expression === undefined) {
+	        // first filter, end of expression
+	        lastFilterIndex = i + 1
+	        dir.expression = str.slice(argIndex, i).trim()
+	      } else {
+	        // already has filter
+	        pushFilter()
+	      }
+	    } else {
+	      switch (c) {
+	        case 0x22: inDouble = true; break // "
+	        case 0x27: inSingle = true; break // '
+	        case 0x28: paren++; break         // (
+	        case 0x29: paren--; break         // )
+	        case 0x5B: square++; break        // [
+	        case 0x5D: square--; break        // ]
+	        case 0x7B: curly++; break         // {
+	        case 0x7D: curly--; break         // }
+	      }
+	    }
+	  }
+
+	  if (i === 0 || begin !== i) {
+	    pushDir()
+	  }
+
+	  cache.put(s, dirs)
+	  return dirs
+	}
+
+/***/ },
+/* 44 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var Path = __webpack_require__(41)
+	var Cache = __webpack_require__(52)
+	var expressionCache = new Cache(1000)
+
+	var keywords =
+	  'Math,break,case,catch,continue,debugger,default,' +
+	  'delete,do,else,false,finally,for,function,if,in,' +
+	  'instanceof,new,null,return,switch,this,throw,true,try,' +
+	  'typeof,var,void,while,with,undefined,abstract,boolean,' +
+	  'byte,char,class,const,double,enum,export,extends,' +
+	  'final,float,goto,implements,import,int,interface,long,' +
+	  'native,package,private,protected,public,short,static,' +
+	  'super,synchronized,throws,transient,volatile,' +
+	  'arguments,let,yield'
+
+	var wsRE = /\s/g
+	var newlineRE = /\n/g
+	var saveRE = /[\{,]\s*[\w\$_]+\s*:|'[^']*'|"[^"]*"/g
+	var restoreRE = /"(\d+)"/g
+	var pathTestRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*$/
+	var pathReplaceRE = /[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g
+	var keywordsRE = new RegExp('^(' + keywords.replace(/,/g, '\\b|') + '\\b)')
+
+	/**
+	 * 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
+	 *
+	 * @param {String} str
+	 * @return {String} - placeholder with index
+	 */
+
+	function save (str) {
+	  var i = saved.length
+	  saved[i] = str.replace(newlineRE, '\\n')
+	  return '"' + i + '"'
+	}
+
+	/**
+	 * Path rewrite replacer
+	 *
+	 * @param {String} raw
+	 * @return {String}
+	 */
+
+	function rewrite (raw) {
+	  var c = raw.charAt(0)
+	  var path = raw.slice(1)
+	  if (keywordsRE.test(path)) {
+	    return raw
+	  } else {
+	    path = path.indexOf('"') > -1
+	      ? path.replace(restoreRE, restore)
+	      : path
+	    return c + 'scope.' + path
+	  }
+	}
+
+	/**
+	 * Restore replacer
+	 *
+	 * @param {String} str
+	 * @param {String} i - matched save index
+	 * @return {String}
+	 */
+
+	function restore (str, i) {
+	  return saved[i]
+	}
+
+	/**
+	 * Rewrite an expression, prefixing all path accessors with
+	 * `scope.` and generate getter/setter functions.
+	 *
+	 * @param {String} exp
+	 * @param {Boolean} needSet
+	 * @return {Function}
+	 */
+
+	function compileExpFns (exp, needSet) {
+	  // 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
+	    }
+	  }
+	}
+
+	/**
+	 * Compile getter setters for a simple path.
+	 *
+	 * @param {String} exp
+	 * @return {Function}
+	 */
+
+	function compilePathFns (exp) {
+	  var getter, path
+	  if (exp.indexOf('[') < 0) {
+	    // really simple path
+	    path = exp.split('.')
+	    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)
+	    }
+	  }
+	}
+
+	/**
+	 * Build a getter function. Requires eval.
+	 *
+	 * We isolate the try/catch so it doesn't affect the
+	 * optimization of the parse function when it is not called.
+	 *
+	 * @param {String} body
+	 * @return {Function|undefined}
+	 */
+
+	function makeGetter (body) {
+	  try {
+	    return new Function('scope', 'return ' + body + ';')
+	  } catch (e) {
+	    _.warn(
+	      'Invalid expression. ' + 
+	      'Generated function body: ' + body
+	    )
+	  }
+	}
+
+	/**
+	 * 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.
+	 *
+	 * @param {String} body
+	 * @return {Function|undefined}
+	 */
+
+	function makeSetter (body) {
+	  try {
+	    return new Function('scope', 'value', body + '=value;')
+	  } catch (e) {
+	    _.warn('Invalid setter function body: ' + body)
+	  }
+	}
+
+	/**
+	 * Check for setter existence on a cache hit.
+	 *
+	 * @param {Function} hit
+	 */
+
+	function checkSetter (hit) {
+	  if (!hit.set) {
+	    hit.set = makeSetter(hit.body)
+	  }
+	}
+
+	/**
+	 * Parse an expression into re-written getter/setters.
+	 *
+	 * @param {String} exp
+	 * @param {Boolean} needSet
+	 * @return {Function}
+	 */
+
+	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.
+	  var res = pathTestRE.test(exp)
+	    ? compilePathFns(exp)
+	    : compileExpFns(exp, needSet)
+	  expressionCache.put(exp, res)
+	  return res
+	}
+
+	// Export the pathRegex for external use
+	exports.pathTestRE = pathTestRE
+
+/***/ },
+/* 45 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var applyCSSTransition = __webpack_require__(53)
+	var applyJSTransition = __webpack_require__(54)
+
+	/**
+	 * Append with transition.
+	 *
+	 * @oaram {Element} el
+	 * @param {Element} target
+	 * @param {Vue} vm
+	 * @param {Function} [cb]
+	 */
+
+	exports.append = function (el, target, vm, cb) {
+	  apply(el, 1, function () {
+	    target.appendChild(el)
+	  }, vm, cb)
+	}
+
+	/**
+	 * InsertBefore with transition.
+	 *
+	 * @oaram {Element} el
+	 * @param {Element} target
+	 * @param {Vue} vm
+	 * @param {Function} [cb]
+	 */
+
+	exports.before = function (el, target, vm, cb) {
+	  apply(el, 1, function () {
+	    _.before(el, target)
+	  }, vm, cb)
+	}
+
+	/**
+	 * Remove with transition.
+	 *
+	 * @oaram {Element} el
+	 * @param {Vue} vm
+	 * @param {Function} [cb]
+	 */
+
+	exports.remove = function (el, vm, cb) {
+	  apply(el, -1, function () {
+	    _.remove(el)
+	  }, vm, cb)
+	}
+
+	/**
+	 * 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]
+	 */
+
+	exports.removeThenAppend = function (el, target, vm, cb) {
+	  apply(el, -1, function () {
+	    target.appendChild(el)
+	  }, vm, cb)
+	}
+
+	/**
+	 * Append the childNodes of a fragment to target.
+	 *
+	 * @param {DocumentFragment} block
+	 * @param {Node} target
+	 * @param {Vue} vm
+	 */
+
+	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)
+	  }
+	}
+
+	/**
+	 * Remove a block of nodes between two edge nodes.
+	 *
+	 * @param {Node} start
+	 * @param {Node} end
+	 * @param {Vue} vm
+	 */
+
+	exports.blockRemove = function (start, end, vm) {
+	  var node = start.nextSibling
+	  var next
+	  while (node !== end) {
+	    next = node.nextSibling
+	    exports.remove(node, vm)
+	    node = next
+	  }
+	}
+
+	/**
+	 * Apply transitions with an operation callback.
+	 *
+	 * @oaram {Element} el
+	 * @param {Number} direction
+	 *                  1: enter
+	 *                 -1: leave
+	 * @param {Function} op - the actual DOM operation
+	 * @param {Vue} vm
+	 * @param {Function} [cb]
+	 */
+
+	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 = vm.$options.transitions[transData.id]
+	  if (jsTransition) {
+	    // js
+	    applyJSTransition(
+	      el,
+	      direction,
+	      op,
+	      transData,
+	      jsTransition,
+	      vm,
+	      cb
+	    )
+	  } else if (_.transitionEndEvent) {
+	    // css
+	    applyCSSTransition(
+	      el,
+	      direction,
+	      op,
+	      transData,
+	      cb
+	    )
+	  } else {
+	    // not applicable
+	    op()
+	    if (cb) cb()
+	  }
+	}
+
+/***/ },
+/* 46 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var config = __webpack_require__(20)
+	var textParser = __webpack_require__(42)
+	var dirParser = __webpack_require__(43)
+	var templateParser = __webpack_require__(51)
+
+	/**
+	 * 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 {Element|DocumentFragment} el
+	 * @param {Object} options
+	 * @param {Boolean} partial
+	 * @return {Function}
+	 */
+
+	module.exports = function compile (el, options, partial) {
+	  var params = !partial && options.paramAttributes
+	  var paramsLinkFn = params
+	    ? compileParamAttributes(el, params, options)
+	    : null
+	  var nodeLinkFn = el instanceof DocumentFragment
+	    ? null
+	    : compileNode(el, options)
+	  var childLinkFn =
+	    (!nodeLinkFn || !nodeLinkFn.terminal) &&
+	    el.hasChildNodes()
+	      ? compileNodeList(el.childNodes, options)
+	      : null
+
+	  /**
+	   * A 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}
+	   */
+
+	  return function link (vm, el) {
+	    var originalDirCount = vm._directives.length
+	    if (paramsLinkFn) paramsLinkFn(vm, el)
+	    if (nodeLinkFn) nodeLinkFn(vm, el)
+	    if (childLinkFn) childLinkFn(vm, el.childNodes)
+
+	    /**
+	     * If this is a partial compile, the linker function
+	     * returns an unlink function that tearsdown all
+	     * directives instances generated during the partial
+	     * linking.
+	     */
+
+	    if (partial) {
+	      var dirs = vm._directives.slice(originalDirCount)
+	      return function unlink () {
+	        var i = dirs.length
+	        while (i--) {
+	          dirs[i]._teardown()
+	        }
+	        i = vm._directives.indexOf(dirs[0])
+	        vm._directives.splice(i, dirs.length)
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Compile a node and return a nodeLinkFn based on the
+	 * node type.
+	 *
+	 * @param {Node} node
+	 * @param {Object} options
+	 * @return {Function|undefined}
+	 */
+
+	function compileNode (node, options) {
+	  var type = node.nodeType
+	  if (type === 1 && node.tagName !== 'SCRIPT') {
+	    return compileElement(node, options)
+	  } else if (type === 3 && config.interpolate) {
+	    return compileTextNode(node, options)
+	  }
+	}
+
+	/**
+	 * Compile an element and return a nodeLinkFn.
+	 *
+	 * @param {Element} el
+	 * @param {Object} options
+	 * @return {Function|null}
+	 */
+
+	function compileElement (el, options) {
+	  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) {
+	      var directives = collectDirectives(el, options)
+	      linkFn = directives.length
+	        ? makeDirectivesLinkFn(directives)
+	        : null
+	    }
+	  }
+	  // 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 multi-directive link function.
+	 *
+	 * @param {Array} directives
+	 * @return {Function} directivesLinkFn
+	 */
+
+	function makeDirectivesLinkFn (directives) {
+	  return function directivesLinkFn (vm, el) {
+	    // 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)
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Compile a textNode and return a nodeLinkFn.
+	 *
+	 * @param {TextNode} node
+	 * @param {Object} options
+	 * @return {Function|null} textNodeLinkFn
+	 */
+
+	function compileTextNode (node, options) {
+	  var tokens = textParser.parse(node.nodeValue)
+	  if (!tokens) {
+	    return null
+	  }
+	  var frag = document.createDocumentFragment()
+	  var dirs = options.directives
+	  var el, token, value
+	  for (var i = 0, l = tokens.length; i < l; i++) {
+	    token = tokens[i]
+	    value = token.value
+	    if (token.tag) {
+	      if (token.oneTime) {
+	        el = document.createTextNode(value)
+	      } else {
+	        if (token.html) {
+	          el = document.createComment('v-html')
+	          token.type = 'html'
+	          token.def = dirs.html
+	          token.descriptor = dirParser.parse(value)[0]
+	        } else if (token.partial) {
+	          el = document.createComment('v-partial')
+	          token.type = 'partial'
+	          token.def = dirs.partial
+	          token.descriptor = dirParser.parse(value)[0]
+	        } else {
+	          // IE will clean up empty textNodes during
+	          // frag.cloneNode(true), so we have to give it
+	          // something here...
+	          el = document.createTextNode(' ')
+	          token.type = 'text'
+	          token.def = dirs.text
+	          token.descriptor = dirParser.parse(value)[0]
+	        }
+	      }
+	    } else {
+	      el = document.createTextNode(value)
+	    }
+	    frag.appendChild(el)
+	  }
+	  return makeTextNodeLinkFn(tokens, frag, options)
+	}
+
+	/**
+	 * Build a function that processes a textNode.
+	 *
+	 * @param {Array<Object>} tokens
+	 * @param {DocumentFragment} frag
+	 */
+
+	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.nodeValue = value
+	          }
+	        } else {
+	          vm._bindDir(token.type, node,
+	                      token.descriptor, token.def)
+	        }
+	      }
+	    }
+	    _.replace(el, fragClone)
+	  }
+	}
+
+	/**
+	 * Compile a node list and return a childLinkFn.
+	 *
+	 * @param {NodeList} nodeList
+	 * @param {Object} options
+	 * @return {Function|undefined}
+	 */
+
+	function compileNodeList (nodeList, options) {
+	  var linkFns = []
+	  var nodeLinkFn, childLinkFn, node
+	  for (var i = 0, l = nodeList.length; i < l; i++) {
+	    node = nodeList[i]
+	    nodeLinkFn = compileNode(node, options)
+	    childLinkFn =
+	      (!nodeLinkFn || !nodeLinkFn.terminal) &&
+	      node.hasChildNodes()
+	        ? compileNodeList(node.childNodes, options)
+	        : null
+	    linkFns.push(nodeLinkFn, childLinkFn)
+	  }
+	  return linkFns.length
+	    ? makeChildLinkFn(linkFns)
+	    : null
+	}
+
+	/**
+	 * Make a child link function for a node's childNodes.
+	 *
+	 * @param {Array<Function>} linkFns
+	 * @return {Function} childLinkFn
+	 */
+
+	function makeChildLinkFn (linkFns) {
+	  return function childLinkFn (vm, nodes) {
+	    // stablize nodes
+	    nodes = _.toArray(nodes)
+	    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++]
+	      if (nodeLinkFn) {
+	        nodeLinkFn(vm, node)
+	      }
+	      if (childrenLinkFn) {
+	        childrenLinkFn(vm, node.childNodes)
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Compile param attributes on a root element and return
+	 * a paramAttributes link function.
+	 *
+	 * @param {Element} el
+	 * @param {Array} attrs
+	 * @param {Object} options
+	 * @return {Function} paramsLinkFn
+	 */
+
+	function compileParamAttributes (el, attrs, options) {
+	  var params = []
+	  var i = attrs.length
+	  var name, value, param
+	  while (i--) {
+	    name = attrs[i]
+	    value = el.getAttribute(name)
+	    if (value !== null) {
+	      param = {
+	        name: name,
+	        value: value
+	      }
+	      var tokens = textParser.parse(value)
+	      if (tokens) {
+	        el.removeAttribute(name)
+	        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)
+	    }
+	  }
+	  return makeParamsLinkFn(params, options)
+	}
+
+	/**
+	 * Build a function that applies param attributes to a vm.
+	 *
+	 * @param {Array} params
+	 * @param {Object} options
+	 * @return {Function} paramsLinkFn
+	 */
+
+	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)
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Check an element for terminal directives in fixed order.
+	 * If it finds one, return a terminal link function.
+	 *
+	 * @param {Element} el
+	 * @param {Object} options
+	 * @return {Function} terminalLinkFn
+	 */
+
+	var terminalDirectives = [
+	  'repeat',
+	  'if',
+	  'component'
+	]
+
+	function skip () {}
+	skip.terminal = true
+
+	function checkTerminalDirectives (el, options) {
+	  if (_.attr(el, 'pre') !== null) {
+	    return skip
+	  }
+	  var value, dirName
+	  /* jshint boss: true */
+	  for (var i = 0; i < 3; i++) {
+	    dirName = terminalDirectives[i]
+	    if (value = _.attr(el, dirName)) {
+	      return makeTeriminalLinkFn(el, dirName, value, options)
+	    }
+	  }
+	}
+
+	/**
+	 * Build a link function for a terminal directive.
+	 *
+	 * @param {Element} el
+	 * @param {String} dirName
+	 * @param {String} value
+	 * @param {Object} options
+	 * @return {Function} terminalLinkFn
+	 */
+
+	function makeTeriminalLinkFn (el, dirName, value, options) {
+	  var descriptor = dirParser.parse(value)[0]
+	  var def = options.directives[dirName]
+	  // special case: we need to collect directives found
+	  // on a component root node, but defined in the parent
+	  // template. These directives need to be compiled in
+	  // the parent scope.
+	  if (dirName === 'component') {
+	    var dirs = collectDirectives(el, options, true)
+	    el._parentLinker = dirs.length
+	      ? makeDirectivesLinkFn(dirs)
+	      : null
+	  }
+	  var terminalLinkFn = function (vm, el) {
+	    vm._bindDir(dirName, el, descriptor, def)
+	  }
+	  terminalLinkFn.terminal = true
+	  return terminalLinkFn
+	}
+
+	/**
+	 * Collect the directives on an element.
+	 *
+	 * @param {Element} el
+	 * @param {Object} options
+	 * @param {Boolean} asParent
+	 * @return {Array}
+	 */
+
+	function collectDirectives (el, options, asParent) {
+	  var attrs = _.toArray(el.attributes)
+	  var i = attrs.length
+	  var dirs = []
+	  var attr, attrName, dir, dirName, dirDef
+	  while (i--) {
+	    attr = attrs[i]
+	    attrName = attr.name
+	    if (attrName.indexOf(config.prefix) === 0) {
+	      dirName = attrName.slice(config.prefix.length)
+	      if (
+	        asParent &&
+	        (dirName === 'with' || dirName === 'ref')
+	      ) {
+	        continue
+	      }
+	      dirDef = options.directives[dirName]
+	      _.assertAsset(dirDef, 'directive', dirName)
+	      if (dirDef) {
+	        dirs.push({
+	          name: dirName,
+	          descriptors: dirParser.parse(attr.value),
+	          def: dirDef
+	        })
+	      }
+	    } else if (config.interpolate) {
+	      dir = collectAttrDirective(el, attrName, attr.value,
+	                                 options)
+	      if (dir) {
+	        dirs.push(dir)
+	      }
+	    }
+	  }
+	  // sort by priority, LOW to HIGH
+	  dirs.sort(directiveComparator)
+	  return dirs
+	}
+
+	/**
+	 * Check an attribute for potential dynamic bindings,
+	 * and return a directive object.
+	 *
+	 * @param {Element} el
+	 * @param {String} name
+	 * @param {String} value
+	 * @param {Object} options
+	 * @return {Object}
+	 */
+
+	function collectAttrDirective (el, 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)
+	          }
+	    }
+	  }
+	}
+
+	/**
+	 * Directive priority sort comparator
+	 *
+	 * @param {Object} a
+	 * @param {Object} b
+	 */
+
+	function directiveComparator (a, b) {
+	  a = a.def.priority || 0
+	  b = b.def.priority || 0
+	  return a > b ? 1 : -1
+	}
+
+/***/ },
+/* 47 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var templateParser = __webpack_require__(51)
+
+	/**
+	 * 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) {
+	  // 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 {
+	    collectRawContent(el)
+	    if (options.replace) {
+	      if (frag.childNodes.length > 1) {
+	        transcludeContent(frag)
+	        return frag
+	      } else {
+	        var replacer = frag.firstChild
+	        _.copyAttributes(el, replacer)
+	        transcludeContent(replacer)
+	        return replacer
+	      }
+	    } else {
+	      el.appendChild(frag)
+	      transcludeContent(el)
+	      return el
+	    }
+	  }
+	}
+
+	/**
+	 * Collect raw content inside $el before they are
+	 * replaced by template content.
+	 */
+
+	var rawContent
+	function collectRawContent (el) {
+	  var child
+	  rawContent = null
+	  if (el.hasChildNodes()) {
+	    rawContent = document.createElement('div')
+	    /* jshint boss:true */
+	    while (child = el.firstChild) {
+	      rawContent.appendChild(child)
+	    }
+	  }
+	}
+
+	/**
+	 * Resolve <content> insertion points mimicking the behavior
+	 * of the Shadow DOM spec:
+	 *
+	 *   http://w3c.github.io/webcomponents/spec/shadow/#insertion-points
+	 *
+	 * @param {Element|DocumentFragment} el
+	 */
+
+	function transcludeContent (el) {
+	  var outlets = getOutlets(el)
+	  var i = outlets.length
+	  if (!i) return
+	  var outlet, select, selected, j, main
+	  // first pass, collect corresponding content
+	  // for each outlet.
+	  while (i--) {
+	    outlet = outlets[i]
+	    if (rawContent) {
+	      select = outlet.getAttribute('select')
+	      if (select) {  // select content
+	        selected = rawContent.querySelectorAll(select)
+	        outlet.content = _.toArray(
+	          selected.length
+	            ? selected
+	            : 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(rawContent.childNodes))
+	  }
+	}
+
+	/**
+	 * 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.
+	 *
+	 * @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)
+	}
+
+/***/ },
+/* 48 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	var handlers = {
+	  _default: __webpack_require__(55),
+	  radio: __webpack_require__(56),
+	  select: __webpack_require__(57),
+	  checkbox: __webpack_require__(58)
+	}
+
+	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
+	    }
+	    handler.bind.call(this)
+	    this.update = handler.update
+	    this.unbind = handler.unbind
+	  }
+
+	}
+
+/***/ },
+/* 49 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var config = __webpack_require__(20)
+	var Binding = __webpack_require__(39)
+	var arrayMethods = __webpack_require__(59)
+	var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
+	__webpack_require__(60)
+
+	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])
+	  }
+	}
+
+	/**
+	 * 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.bindings = []
+	  _.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)
+	  }
+	}
+
+	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.
+	 *
+	 * @param {*} value
+	 * @return {Observer|undefined}
+	 * @static
+	 */
+
+	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)
+	  }
+	}
+
+	/**
+	 * 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 {Object} obj
+	 */
+
+	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])
+	    }
+	  }
+	}
+
+	/**
+	 * Try to carete an observer for a child value,
+	 * and if value is array, link binding to the array.
+	 *
+	 * @param {*} val
+	 * @return {Binding|undefined}
+	 */
+
+	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--) {
+	    this.observe(items[i])
+	  }
+	}
+
+	/**
+	 * Convert a property into getter/setter so we can emit
+	 * the events when the property is accessed/changed.
+	 *
+	 * @param {String} key
+	 * @param {*} val
+	 */
+
+	p.convert = function (key, val) {
+	  var ob = this
+	  var childOb = ob.observe(val)
+	  var binding = new Binding()
+	  if (childOb) {
+	    childOb.bindings.push(binding)
+	  }
+	  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(binding)
+	      }
+	      return val
+	    },
+	    set: function (newVal) {
+	      if (newVal === val) return
+	      // remove binding from old value
+	      var oldChildOb = val && val.__ob__
+	      if (oldChildOb) {
+	        var oldBindings = oldChildOb.bindings
+	        oldBindings.splice(oldBindings.indexOf(binding), 1)
+	      }
+	      val = newVal
+	      // add binding to new value
+	      var newChildOb = ob.observe(newVal)
+	      if (newChildOb) {
+	        newChildOb.bindings.push(binding)
+	      }
+	      binding.notify()
+	    }
+	  })
+	}
+
+	/**
+	 * Notify change on all self bindings 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.
+	 */
+
+	p.notify = function () {
+	  var bindings = this.bindings
+	  for (var i = 0, l = bindings.length; i < l; i++) {
+	    bindings[i].notify()
+	  }
+	}
+
+	/**
+	 * 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 {Vue} vm
+	 */
+
+	p.addVm = function (vm) {
+	  (this.vms = this.vms || []).push(vm)
+	}
+
+	/**
+	 * Remove an owner vm. This is called when the object is
+	 * swapped out as an instance's $data object.
+	 *
+	 * @param {Vue} vm
+	 */
+
+	p.removeVm = function (vm) {
+	  this.vms.splice(this.vms.indexOf(vm), 1)
+	}
+
+	module.exports = Observer
+
+
+/***/ },
+/* 50 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	/**
+	 * The Batcher maintains a job queue to be run
+	 * async on the next event loop.
+	 */
+
+	function Batcher () {
+	  this.reset()
+	}
+
+	var p = Batcher.prototype
+
+	/**
+	 * 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
+	 */
+
+	p.push = function (job) {
+	  if (!job.id || !this.has[job.id] || this.flushing) {
+	    this.queue.push(job)
+	    this.has[job.id] = job
+	    if (!this.waiting) {
+	      this.waiting = true
+	      _.nextTick(this.flush, this)
+	    }
+	  }
+	}
+
+	/**
+	 * Flush the queue and run the jobs.
+	 * Will call a preFlush hook if has one.
+	 */
+
+	p.flush = function () {
+	  this.flushing = true
+	  // do not cache length because more jobs might be pushed
+	  // as we run existing jobs
+	  for (var i = 0; i < this.queue.length; i++) {
+	    var job = this.queue[i]
+	    if (!job.cancelled) {
+	      job.run()
+	    }
+	  }
+	  this.reset()
+	}
+
+	/**
+	 * Reset the batcher's state.
+	 */
+
+	p.reset = function () {
+	  this.has = {}
+	  this.queue = []
+	  this.waiting = false
+	  this.flushing = false
+	}
+
+	module.exports = Batcher
+
+/***/ },
+/* 51 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var Cache = __webpack_require__(52)
+	var templateCache = new Cache(100)
+
+	/**
+	 * 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
+
+	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 TAG_RE = /<([\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 = TAG_RE.exec(templateString)
+
+	  if (!tagMatch) {
+	    // text only, return a single text node.
+	    frag.appendChild(
+	      document.createTextNode(templateString)
+	    )
+	  } else {
+
+	    var tag    = 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
+	  }
+	  return tag === 'SCRIPT'
+	    ? stringToFragment(node.textContent)
+	    : stringToFragment(node.innerHTML)
+	}
+
+	/**
+	 * Deal with Safari cloning nested <template> bug by
+	 * manually cloning all template instances.
+	 *
+	 * @param {Element|DocumentFragment} node
+	 * @return {Element|DocumentFragment}
+	 */
+
+	exports.clone = function (node) {
+	  var res = node.cloneNode(true)
+	  /* istanbul ignore if */
+	  if (hasBrokenTemplate) {
+	    var templates = node.querySelectorAll('template')
+	    if (templates.length) {
+	      var cloned = res.querySelectorAll('template')
+	      var i = cloned.length
+	      while (i--) {
+	        cloned[i].parentNode.replaceChild(
+	          templates[i].cloneNode(true),
+	          cloned[i]
+	        )
+	      }
+	    }
+	  }
+	  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
+	 * @return {DocumentFragment|undefined}
+	 */
+
+	exports.parse = function (template, clone) {
+	  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 (template.charAt(0) === '#') {
+	      // id selector can be cached too
+	      frag = templateCache.get(template)
+	      if (!frag) {
+	        node = document.getElementById(template.slice(1))
+	        if (node) {
+	          frag = nodeToFragment(node)
+	          // save selector to cache
+	          templateCache.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
+	}
+
+/***/ },
+/* 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).
+	 *
+	 * @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++
+	  }
+	}
+
+	/**
+	 * 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
+
+/***/ },
+/* 53 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	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)
+	  }
+	}
+
+	/**
+	 * Flush the queue, and do one forced reflow before
+	 * triggering transitions.
+	 */
+
+	function flush () {
+	  /* jshint unused: false */
+	  var f = document.documentElement.offsetHeight
+	  queue.forEach(run)
+	  queue = []
+	  queued = false
+	}
+
+	/**
+	 * Run a transition job.
+	 *
+	 * @param {Object} job
+	 */
+
+	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)
+	  }
+	}
+
+	/**
+	 * Get an element's transition type based on the
+	 * calculated styles
+	 *
+	 * @param {Element} el
+	 * @param {Object} data
+	 * @param {String} className
+	 * @return {Number}
+	 *         1 - transition
+	 *         2 - animation
+	 */
+
+	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
+	}
+
+	/**
+	 * Apply CSS transition to an element.
+	 *
+	 * @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)
+	  }
+	}
+
+/***/ },
+/* 54 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Apply JavaScript enter/leave functions.
+	 *
+	 * @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]
+	 */
+
+	module.exports = function (el, direction, op, data, def, vm, cb) {
+	  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()
+	    }
+	  }
+	}
+
+/***/ },
+/* 55 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	module.exports = {
+
+	  bind: function () {
+	    var self = this
+	    var el = this.el
+
+	    // check params
+	    // - lazy: update model on "change" instead of "input"
+	    var lazy = el.hasAttribute('lazy')
+	    if (lazy) {
+	      el.removeAttribute('lazy')
+	    }
+	    // - number: cast value into number when updating model.
+	    var number =
+	      el.hasAttribute('number') ||
+	      el.type === 'number'
+	    if (number) {
+	      el.removeAttribute('number')
+	    }
+
+	    // 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.
+	    this.listener = 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) {}
+	      set()
+	      // 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.
+	      _.nextTick(function () {
+	        var newVal = self._watcher.value
+	        self.update(newVal)
+	        if (charsOffset != null) {
+	          var cursorPos =
+	            _.toString(newVal).length - charsOffset
+	          el.setSelectionRange(cursorPos, cursorPos)
+	        }
+	      })
+	    }
+	    this.event = lazy ? 'change' : 'input'
+	    _.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
+	    }
+	  },
+
+	  update: function (value) {
+	    this.el.value = _.toString(value)
+	  },
+
+	  unbind: function () {
+	    var el = this.el
+	    _.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)
+	    }
+	  }
+
+	}
+
+/***/ },
+/* 56 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	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)
+	  }
+
+	}
+
+/***/ },
+/* 57 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var Watcher = __webpack_require__(21)
+
+	module.exports = {
+
+	  bind: function () {
+	    var self = this
+	    var el = this.el
+	    // check options param
+	    var optionsParam = el.getAttribute('options')
+	    if (optionsParam) {
+	      el.removeAttribute('options')
+	      initOptions.call(this, optionsParam)
+	    }
+	    this.multiple = el.hasAttribute('multiple')
+	    this.listener = function () {
+	      var value = self.multiple
+	        ? getMultiValue(el)
+	        : el.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()
+	    }
+	  }
+
+	}
+
+	/**
+	 * Initialize the option list from the param.
+	 *
+	 * @param {String} expression
+	 */
+
+	function initOptions (expression) {
+	  var self = this
+	  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)
+	    }
+	  }
+	  this.optionWatcher = new Watcher(
+	    this.vm,
+	    expression,
+	    optionUpdateWatcher
+	  )
+	  // update with initial value
+	  optionUpdateWatcher(this.optionWatcher.value)
+	}
+
+	/**
+	 * Build up option elements. IE9 doesn't create options
+	 * when setting innerHTML on <select> elements, so we have
+	 * to use DOM API here.
+	 *
+	 * @param {Element} parent - a <select> or an <optgroup>
+	 * @param {Array} options
+	 */
+
+	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)
+	    }
+	    parent.appendChild(el)
+	  }
+	}
+
+	/**
+	 * Check the initial value for selected options.
+	 */
+
+	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 (initValue) {
+	    this._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
+	}
+
+	function getOptionValue (op) {
+	  return op.value || op.text
+	}
+
+	/**
+	 * Native Array.indexOf uses strict equal, but in this
+	 * case we need to match string/numbers with soft equal.
+	 *
+	 * @param {Array} arr
+	 * @param {*} val
+	 */
+
+	function indexOf (arr, val) {
+	  /* jshint eqeqeq: false */
+	  var i = arr.length
+	  while (i--) {
+	    if (arr[i] == val) return i
+	  }
+	  return -1
+	}
+
+/***/ },
+/* 58 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+
+	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
+	    }
+	  },
+
+	  update: function (value) {
+	    this.el.checked = !!value
+	  },
+
+	  unbind: function () {
+	    _.off(this.el, 'change', this.listener)
+	  }
+
+	}
+
+/***/ },
+/* 59 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var arrayProto = Array.prototype
+	var arrayMethods = Object.create(arrayProto)
+
+	/**
+	 * Intercept mutating methods and emit events
+	 */
+
+	;[
+	  'push',
+	  'pop',
+	  'shift',
+	  'unshift',
+	  'splice',
+	  'sort',
+	  'reverse'
+	]
+	.forEach(function (method) {
+	  // cache original method
+	  var original = arrayProto[method]
+	  _.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
+	  })
+	})
+
+	/**
+	 * Swap the element at the given index with a new value
+	 * and emits corresponding event.
+	 *
+	 * @param {Number} index
+	 * @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]
+	  }
+	)
+
+	/**
+	 * Convenience method to remove the element at given index.
+	 *
+	 * @param {Number} index
+	 * @param {*} val
+	 */
+
+	_.define(
+	  arrayProto,
+	  '$remove',
+	  function $remove (index) {
+	    if (typeof index !== 'number') {
+	      index = this.indexOf(index)
+	    }
+	    if (index > -1) {
+	      return this.splice(index, 1)[0]
+	    }
+	  }
+	)
+
+	module.exports = arrayMethods
+
+/***/ },
+/* 60 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(1)
+	var objProto = Object.prototype
+
+	/**
+	 * Add a new property to an observed object
+	 * and emits corresponding event
+	 *
+	 * @param {String} key
+	 * @param {*} val
+	 * @public
+	 */
+
+	_.define(
+	  objProto,
+	  '$add',
+	  function $add (key, val) {
+	    var ob = this.__ob__
+	    if (!ob) {
+	      this[key] = val
+	      return
+	    }
+	    if (_.isReserved(key)) {
+	      _.warn('Refused to $add reserved key: ' + key)
+	      return
+	    }
+	    if (this.hasOwnProperty(key)) 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()
+	    }
+	  }
+	)
+
+	/**
+	 * Deletes a property from an observed object
+	 * and emits corresponding event
+	 *
+	 * @param {String} key
+	 * @public
+	 */
+
+	_.define(
+	  objProto,
+	  '$delete',
+	  function $delete (key) {
+	    var ob = this.__ob__
+	    if (!ob) {
+	      delete this[key]
+	      return
+	    }
+	    if (_.isReserved(key)) {
+	      _.warn('Refused to $add reserved key: ' + key)
+	      return
+	    }
+	    if (!this.hasOwnProperty(key)) return
+	    delete this[key]
+	    if (ob.vms) {
+	      var i = ob.vms.length
+	      while (i--) {
+	        var vm = ob.vms[i]
+	        vm._unproxy(key)
+	        vm._digest()
+	      }
+	    } else {
+	      ob.notify()
+	    }
+	  }
+	)
+
+/***/ }
+/******/ ])
 });
-require.register("vue/src/emitter.js", function(exports, require, module){
-var slice = [].slice
-
-function Emitter (ctx) {
-    this._ctx = ctx || this
-}
-
-var EmitterProto = Emitter.prototype
-
-EmitterProto.on = function (event, fn) {
-    this._cbs = this._cbs || {}
-    ;(this._cbs[event] = this._cbs[event] || [])
-        .push(fn)
-    return this
-}
-
-EmitterProto.once = function (event, fn) {
-    var self = this
-    this._cbs = this._cbs || {}
-
-    function on () {
-        self.off(event, on)
-        fn.apply(this, arguments)
-    }
-
-    on.fn = fn
-    this.on(event, on)
-    return this
-}
-
-EmitterProto.off = function (event, fn) {
-    this._cbs = this._cbs || {}
-
-    // all
-    if (!arguments.length) {
-        this._cbs = {}
-        return this
-    }
-
-    // specific event
-    var callbacks = this._cbs[event]
-    if (!callbacks) return this
-
-    // remove all handlers
-    if (arguments.length === 1) {
-        delete this._cbs[event]
-        return this
-    }
-
-    // remove specific handler
-    var cb
-    for (var i = 0; i < callbacks.length; i++) {
-        cb = callbacks[i]
-        if (cb === fn || cb.fn === fn) {
-            callbacks.splice(i, 1)
-            break
-        }
-    }
-    return this
-}
-
-/**
- *  The internal, faster emit with fixed amount of arguments
- *  using Function.call
- */
-EmitterProto.emit = function (event, a, b, c) {
-    this._cbs = this._cbs || {}
-    var callbacks = this._cbs[event]
-
-    if (callbacks) {
-        callbacks = callbacks.slice(0)
-        for (var i = 0, len = callbacks.length; i < len; i++) {
-            callbacks[i].call(this._ctx, a, b, c)
-        }
-    }
-
-    return this
-}
-
-/**
- *  The external emit using Function.apply
- */
-EmitterProto.applyEmit = function (event) {
-    this._cbs = this._cbs || {}
-    var callbacks = this._cbs[event], args
-
-    if (callbacks) {
-        callbacks = callbacks.slice(0)
-        args = slice.call(arguments, 1)
-        for (var i = 0, len = callbacks.length; i < len; i++) {
-            callbacks[i].apply(this._ctx, args)
-        }
-    }
-
-    return this
-}
-
-module.exports = Emitter
-});
-require.register("vue/src/config.js", function(exports, require, module){
-var TextParser = require('./text-parser')
-
-module.exports = {
-    prefix         : 'v',
-    debug          : false,
-    silent         : false,
-    enterClass     : 'v-enter',
-    leaveClass     : 'v-leave',
-    interpolate    : true
-}
-
-Object.defineProperty(module.exports, 'delimiters', {
-    get: function () {
-        return TextParser.delimiters
-    },
-    set: function (delimiters) {
-        TextParser.setDelimiters(delimiters)
-    }
-})
-});
-require.register("vue/src/utils.js", function(exports, require, module){
-var config       = require('./config'),
-    toString     = ({}).toString,
-    win          = window,
-    console      = win.console,
-    def          = Object.defineProperty,
-    OBJECT       = 'object',
-    THIS_RE      = /[^\w]this[^\w]/,
-    BRACKET_RE_S = /\['([^']+)'\]/g,
-    BRACKET_RE_D = /\["([^"]+)"\]/g,
-    hasClassList = 'classList' in document.documentElement,
-    ViewModel // late def
-
-var defer =
-    win.requestAnimationFrame ||
-    win.webkitRequestAnimationFrame ||
-    win.setTimeout
-
-/**
- *  Normalize keypath with possible brackets into dot notations
- */
-function normalizeKeypath (key) {
-    return key.indexOf('[') < 0
-        ? key
-        : key.replace(BRACKET_RE_S, '.$1')
-             .replace(BRACKET_RE_D, '.$1')
-}
-
-var utils = module.exports = {
-
-    /**
-     *  Convert a string template to a dom fragment
-     */
-    toFragment: require('./fragment'),
-
-    /**
-     *  Parse the various types of template options
-     */
-    parseTemplateOption: require('./template-parser.js'),
-
-    /**
-     *  get a value from an object keypath
-     */
-    get: function (obj, key) {
-        /* jshint eqeqeq: false */
-        key = normalizeKeypath(key)
-        if (key.indexOf('.') < 0) {
-            return obj[key]
-        }
-        var path = key.split('.'),
-            d = -1, l = path.length
-        while (++d < l && obj != null) {
-            obj = obj[path[d]]
-        }
-        return obj
-    },
-
-    /**
-     *  set a value to an object keypath
-     */
-    set: function (obj, key, val) {
-        /* jshint eqeqeq: false */
-        key = normalizeKeypath(key)
-        if (key.indexOf('.') < 0) {
-            obj[key] = val
-            return
-        }
-        var path = key.split('.'),
-            d = -1, l = path.length - 1
-        while (++d < l) {
-            if (obj[path[d]] == null) {
-                obj[path[d]] = {}
-            }
-            obj = obj[path[d]]
-        }
-        obj[path[d]] = val
-    },
-
-    /**
-     *  return the base segment of a keypath
-     */
-    baseKey: function (key) {
-        return key.indexOf('.') > 0
-            ? key.split('.')[0]
-            : key
-    },
-
-    /**
-     *  Create a prototype-less object
-     *  which is a better hash/map
-     */
-    hash: function () {
-        return Object.create(null)
-    },
-
-    /**
-     *  get an attribute and remove it.
-     */
-    attr: function (el, type) {
-        var attr = config.prefix + '-' + type,
-            val = el.getAttribute(attr)
-        if (val !== null) {
-            el.removeAttribute(attr)
-        }
-        return val
-    },
-
-    /**
-     *  Define an ienumerable property
-     *  This avoids it being included in JSON.stringify
-     *  or for...in loops.
-     */
-    defProtected: function (obj, key, val, enumerable, writable) {
-        def(obj, key, {
-            value        : val,
-            enumerable   : enumerable,
-            writable     : writable,
-            configurable : true
-        })
-    },
-
-    /**
-     *  A less bullet-proof but more efficient type check
-     *  than Object.prototype.toString
-     */
-    isObject: function (obj) {
-        return typeof obj === OBJECT && obj && !Array.isArray(obj)
-    },
-
-    /**
-     *  A more accurate but less efficient type check
-     */
-    isTrueObject: function (obj) {
-        return toString.call(obj) === '[object Object]'
-    },
-
-    /**
-     *  Most simple bind
-     *  enough for the usecase and fast than native bind()
-     */
-    bind: function (fn, ctx) {
-        return function (arg) {
-            return fn.call(ctx, arg)
-        }
-    },
-
-    /**
-     *  Make sure null and undefined output empty string
-     */
-    guard: function (value) {
-        /* jshint eqeqeq: false, eqnull: true */
-        return value == null
-            ? ''
-            : (typeof value == 'object')
-                ? JSON.stringify(value)
-                : value
-    },
-
-    /**
-     *  When setting value on the VM, parse possible numbers
-     */
-    checkNumber: function (value) {
-        return (isNaN(value) || value === null || typeof value === 'boolean')
-            ? value
-            : Number(value)
-    },
-
-    /**
-     *  simple extend
-     */
-    extend: function (obj, ext) {
-        for (var key in ext) {
-            if (obj[key] !== ext[key]) {
-                obj[key] = ext[key]
-            }
-        }
-        return obj
-    },
-
-    /**
-     *  filter an array with duplicates into uniques
-     */
-    unique: function (arr) {
-        var hash = utils.hash(),
-            i = arr.length,
-            key, res = []
-        while (i--) {
-            key = arr[i]
-            if (hash[key]) continue
-            hash[key] = 1
-            res.push(key)
-        }
-        return res
-    },
-
-    /**
-     *  Convert the object to a ViewModel constructor
-     *  if it is not already one
-     */
-    toConstructor: function (obj) {
-        ViewModel = ViewModel || require('./viewmodel')
-        return utils.isObject(obj)
-            ? ViewModel.extend(obj)
-            : typeof obj === 'function'
-                ? obj
-                : null
-    },
-
-    /**
-     *  Check if a filter function contains references to `this`
-     *  If yes, mark it as a computed filter.
-     */
-    checkFilter: function (filter) {
-        if (THIS_RE.test(filter.toString())) {
-            filter.computed = true
-        }
-    },
-
-    /**
-     *  convert certain option values to the desired format.
-     */
-    processOptions: function (options) {
-        var components = options.components,
-            partials   = options.partials,
-            template   = options.template,
-            filters    = options.filters,
-            key
-        if (components) {
-            for (key in components) {
-                components[key] = utils.toConstructor(components[key])
-            }
-        }
-        if (partials) {
-            for (key in partials) {
-                partials[key] = utils.parseTemplateOption(partials[key])
-            }
-        }
-        if (filters) {
-            for (key in filters) {
-                utils.checkFilter(filters[key])
-            }
-        }
-        if (template) {
-            options.template = utils.parseTemplateOption(template)
-        }
-    },
-
-    /**
-     *  used to defer batch updates
-     */
-    nextTick: function (cb) {
-        defer(cb, 0)
-    },
-
-    /**
-     *  add class for IE9
-     *  uses classList if available
-     */
-    addClass: function (el, cls) {
-        if (hasClassList) {
-            el.classList.add(cls)
-        } else {
-            var cur = ' ' + el.className + ' '
-            if (cur.indexOf(' ' + cls + ' ') < 0) {
-                el.className = (cur + cls).trim()
-            }
-        }
-    },
-
-    /**
-     *  remove class for IE9
-     */
-    removeClass: function (el, cls) {
-        if (hasClassList) {
-            el.classList.remove(cls)
-        } else {
-            var cur = ' ' + el.className + ' ',
-                tar = ' ' + cls + ' '
-            while (cur.indexOf(tar) >= 0) {
-                cur = cur.replace(tar, ' ')
-            }
-            el.className = cur.trim()
-        }
-    },
-
-    /**
-     *  Convert an object to Array
-     *  used in v-repeat and array filters
-     */
-    objectToArray: function (obj) {
-        var res = [], val, data
-        for (var key in obj) {
-            val = obj[key]
-            data = utils.isObject(val)
-                ? val
-                : { $value: val }
-            data.$key = key
-            res.push(data)
-        }
-        return res
-    }
-}
-
-enableDebug()
-function enableDebug () {
-    /**
-     *  log for debugging
-     */
-    utils.log = function (msg) {
-        if (config.debug && console) {
-            console.log(msg)
-        }
-    }
-    
-    /**
-     *  warnings, traces by default
-     *  can be suppressed by `silent` option.
-     */
-    utils.warn = function (msg) {
-        if (!config.silent && console) {
-            console.warn(msg)
-            if (config.debug && console.trace) {
-                console.trace()
-            }
-        }
-    }
-}
-});
-require.register("vue/src/fragment.js", function(exports, require, module){
-// string -> DOM conversion
-// wrappers originally from jQuery, scooped from component/domify
-var map = {
-    legend   : [1, '<fieldset>', '</fieldset>'],
-    tr       : [2, '<table><tbody>', '</tbody></table>'],
-    col      : [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
-    _default : [0, '', '']
-}
-
-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.text =
-map.circle =
-map.ellipse =
-map.line =
-map.path =
-map.polygon =
-map.polyline =
-map.rect = [1, '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">','</svg>']
-
-var TAG_RE = /<([\w:]+)/
-
-module.exports = function (templateString) {
-    var frag = document.createDocumentFragment(),
-        m = TAG_RE.exec(templateString)
-    // text only
-    if (!m) {
-        frag.appendChild(document.createTextNode(templateString))
-        return frag
-    }
-
-    var tag = m[1],
-        wrap = map[tag] || map._default,
-        depth = wrap[0],
-        prefix = wrap[1],
-        suffix = wrap[2],
-        node = document.createElement('div')
-
-    node.innerHTML = prefix + templateString.trim() + suffix
-    while (depth--) node = node.lastChild
-
-    // one element
-    if (node.firstChild === node.lastChild) {
-        frag.appendChild(node.firstChild)
-        return frag
-    }
-
-    // multiple nodes, return a fragment
-    var child
-    /* jshint boss: true */
-    while (child = node.firstChild) {
-        if (node.nodeType === 1) {
-            frag.appendChild(child)
-        }
-    }
-    return frag
-}
-});
-require.register("vue/src/compiler.js", function(exports, require, module){
-var Emitter     = require('./emitter'),
-    Observer    = require('./observer'),
-    config      = require('./config'),
-    utils       = require('./utils'),
-    Binding     = require('./binding'),
-    Directive   = require('./directive'),
-    TextParser  = require('./text-parser'),
-    DepsParser  = require('./deps-parser'),
-    ExpParser   = require('./exp-parser'),
-    ViewModel,
-    
-    // cache methods
-    slice       = [].slice,
-    extend      = utils.extend,
-    hasOwn      = ({}).hasOwnProperty,
-    def         = Object.defineProperty,
-
-    // hooks to register
-    hooks = [
-        'created', 'ready',
-        'beforeDestroy', 'afterDestroy',
-        'attached', 'detached'
-    ],
-
-    // list of priority directives
-    // that needs to be checked in specific order
-    priorityDirectives = [
-        'if',
-        'repeat',
-        'view',
-        'component'
-    ]
-
-/**
- *  The DOM compiler
- *  scans a DOM node and compile bindings for a ViewModel
- */
-function Compiler (vm, options) {
-
-    var compiler = this,
-        key, i
-
-    // default state
-    compiler.init       = true
-    compiler.destroyed  = false
-
-    // process and extend options
-    options = compiler.options = options || {}
-    utils.processOptions(options)
-
-    // copy compiler options
-    extend(compiler, options.compilerOptions)
-    // repeat indicates this is a v-repeat instance
-    compiler.repeat   = compiler.repeat || false
-    // expCache will be shared between v-repeat instances
-    compiler.expCache = compiler.expCache || {}
-
-    // initialize element
-    var el = compiler.el = compiler.setupElement(options)
-    utils.log('\nnew VM instance: ' + el.tagName + '\n')
-
-    // set other compiler properties
-    compiler.vm       = el.vue_vm = vm
-    compiler.bindings = utils.hash()
-    compiler.dirs     = []
-    compiler.deferred = []
-    compiler.computed = []
-    compiler.children = []
-    compiler.emitter  = new Emitter(vm)
-
-    // VM ---------------------------------------------------------------------
-
-    // set VM properties
-    vm.$         = {}
-    vm.$el       = el
-    vm.$options  = options
-    vm.$compiler = compiler
-    vm.$event    = null
-
-    // set parent & root
-    var parentVM = options.parent
-    if (parentVM) {
-        compiler.parent = parentVM.$compiler
-        parentVM.$compiler.children.push(compiler)
-        vm.$parent = parentVM
-        // inherit lazy option
-        if (!('lazy' in options)) {
-            options.lazy = compiler.parent.options.lazy
-        }
-    }
-    vm.$root = getRoot(compiler).vm
-
-    // DATA -------------------------------------------------------------------
-
-    // setup observer
-    // this is necesarry for all hooks and data observation events
-    compiler.setupObserver()
-
-    // create bindings for computed properties
-    if (options.methods) {
-        for (key in options.methods) {
-            compiler.createBinding(key)
-        }
-    }
-
-    // create bindings for methods
-    if (options.computed) {
-        for (key in options.computed) {
-            compiler.createBinding(key)
-        }
-    }
-
-    // initialize data
-    var data = compiler.data = options.data || {},
-        defaultData = options.defaultData
-    if (defaultData) {
-        for (key in defaultData) {
-            if (!hasOwn.call(data, key)) {
-                data[key] = defaultData[key]
-            }
-        }
-    }
-
-    // copy paramAttributes
-    var params = options.paramAttributes
-    if (params) {
-        i = params.length
-        while (i--) {
-            data[params[i]] = utils.checkNumber(
-                compiler.eval(
-                    el.getAttribute(params[i])
-                )
-            )
-        }
-    }
-
-    // copy data properties to vm
-    // so user can access them in the created hook
-    extend(vm, data)
-    vm.$data = data
-
-    // beforeCompile hook
-    compiler.execHook('created')
-
-    // the user might have swapped the data ...
-    data = compiler.data = vm.$data
-
-    // user might also set some properties on the vm
-    // in which case we should copy back to $data
-    var vmProp
-    for (key in vm) {
-        vmProp = vm[key]
-        if (
-            key.charAt(0) !== '$' &&
-            data[key] !== vmProp &&
-            typeof vmProp !== 'function'
-        ) {
-            data[key] = vmProp
-        }
-    }
-
-    // now we can observe the data.
-    // this will convert data properties to getter/setters
-    // and emit the first batch of set events, which will
-    // in turn create the corresponding bindings.
-    compiler.observeData(data)
-
-    // COMPILE ----------------------------------------------------------------
-
-    // before compiling, resolve content insertion points
-    if (options.template) {
-        this.resolveContent()
-    }
-
-    // now parse the DOM and bind directives.
-    // During this stage, we will also create bindings for
-    // encountered keypaths that don't have a binding yet.
-    compiler.compile(el, true)
-
-    // Any directive that creates child VMs are deferred
-    // so that when they are compiled, all bindings on the
-    // parent VM have been created.
-    i = compiler.deferred.length
-    while (i--) {
-        compiler.bindDirective(compiler.deferred[i])
-    }
-    compiler.deferred = null
-
-    // extract dependencies for computed properties.
-    // this will evaluated all collected computed bindings
-    // and collect get events that are emitted.
-    if (this.computed.length) {
-        DepsParser.parse(this.computed)
-    }
-
-    // done!
-    compiler.init = false
-
-    // post compile / ready hook
-    compiler.execHook('ready')
-}
-
-var CompilerProto = Compiler.prototype
-
-/**
- *  Initialize the VM/Compiler's element.
- *  Fill it in with the template if necessary.
- */
-CompilerProto.setupElement = function (options) {
-    // create the node first
-    var el = typeof options.el === 'string'
-        ? document.querySelector(options.el)
-        : options.el || document.createElement(options.tagName || 'div')
-
-    var template = options.template,
-        child, replacer, i, attr, attrs
-
-    if (template) {
-        // collect anything already in there
-        if (el.hasChildNodes()) {
-            this.rawContent = document.createElement('div')
-            /* jshint boss: true */
-            while (child = el.firstChild) {
-                this.rawContent.appendChild(child)
-            }
-        }
-        // replace option: use the first node in
-        // the template directly
-        if (options.replace && template.firstChild === template.lastChild) {
-            replacer = template.firstChild.cloneNode(true)
-            if (el.parentNode) {
-                el.parentNode.insertBefore(replacer, el)
-                el.parentNode.removeChild(el)
-            }
-            // copy over attributes
-            if (el.hasAttributes()) {
-                i = el.attributes.length
-                while (i--) {
-                    attr = el.attributes[i]
-                    replacer.setAttribute(attr.name, attr.value)
-                }
-            }
-            // replace
-            el = replacer
-        } else {
-            el.appendChild(template.cloneNode(true))
-        }
-
-    }
-
-    // apply element options
-    if (options.id) el.id = options.id
-    if (options.className) el.className = options.className
-    attrs = options.attributes
-    if (attrs) {
-        for (attr in attrs) {
-            el.setAttribute(attr, attrs[attr])
-        }
-    }
-
-    return el
-}
-
-/**
- *  Deal with <content> insertion points
- *  per the Web Components spec
- */
-CompilerProto.resolveContent = function () {
-
-    var outlets = slice.call(this.el.getElementsByTagName('content')),
-        raw = this.rawContent,
-        outlet, select, i, j, main
-
-    i = outlets.length
-    if (i) {
-        // first pass, collect corresponding content
-        // for each outlet.
-        while (i--) {
-            outlet = outlets[i]
-            if (raw) {
-                select = outlet.getAttribute('select')
-                if (select) { // select content
-                    outlet.content =
-                        slice.call(raw.querySelectorAll(select))
-                } else { // default content
-                    main = outlet
-                }
-            } else { // fallback content
-                outlet.content =
-                    slice.call(outlet.childNodes)
-            }
-        }
-        // second pass, actually insert the contents
-        for (i = 0, j = outlets.length; i < j; i++) {
-            outlet = outlets[i]
-            if (outlet === main) continue
-            insert(outlet, outlet.content)
-        }
-        // finally insert the main content
-        if (raw && main) {
-            insert(main, slice.call(raw.childNodes))
-        }
-    }
-
-    function insert (outlet, contents) {
-        var parent = outlet.parentNode,
-            i = 0, j = contents.length
-        for (; i < j; i++) {
-            parent.insertBefore(contents[i], outlet)
-        }
-        parent.removeChild(outlet)
-    }
-
-    this.rawContent = null
-}
-
-/**
- *  Setup observer.
- *  The observer listens for get/set/mutate events on all VM
- *  values/objects and trigger corresponding binding updates.
- *  It also listens for lifecycle hooks.
- */
-CompilerProto.setupObserver = function () {
-
-    var compiler = this,
-        bindings = compiler.bindings,
-        options  = compiler.options,
-        observer = compiler.observer = new Emitter(compiler.vm)
-
-    // a hash to hold event proxies for each root level key
-    // so they can be referenced and removed later
-    observer.proxies = {}
-
-    // add own listeners which trigger binding updates
-    observer
-        .on('get', onGet)
-        .on('set', onSet)
-        .on('mutate', onSet)
-
-    // register hooks
-    var i = hooks.length, j, hook, fns
-    while (i--) {
-        hook = hooks[i]
-        fns = options[hook]
-        if (Array.isArray(fns)) {
-            j = fns.length
-            // since hooks were merged with child at head,
-            // we loop reversely.
-            while (j--) {
-                registerHook(hook, fns[j])
-            }
-        } else if (fns) {
-            registerHook(hook, fns)
-        }
-    }
-
-    // broadcast attached/detached hooks
-    observer
-        .on('hook:attached', function () {
-            broadcast(1)
-        })
-        .on('hook:detached', function () {
-            broadcast(0)
-        })
-
-    function onGet (key) {
-        check(key)
-        DepsParser.catcher.emit('get', bindings[key])
-    }
-
-    function onSet (key, val, mutation) {
-        observer.emit('change:' + key, val, mutation)
-        check(key)
-        bindings[key].update(val)
-    }
-
-    function registerHook (hook, fn) {
-        observer.on('hook:' + hook, function () {
-            fn.call(compiler.vm)
-        })
-    }
-
-    function broadcast (event) {
-        var children = compiler.children
-        if (children) {
-            var child, i = children.length
-            while (i--) {
-                child = children[i]
-                if (child.el.parentNode) {
-                    event = 'hook:' + (event ? 'attached' : 'detached')
-                    child.observer.emit(event)
-                    child.emitter.emit(event)
-                }
-            }
-        }
-    }
-
-    function check (key) {
-        if (!bindings[key]) {
-            compiler.createBinding(key)
-        }
-    }
-}
-
-CompilerProto.observeData = function (data) {
-
-    var compiler = this,
-        observer = compiler.observer
-
-    // recursively observe nested properties
-    Observer.observe(data, '', observer)
-
-    // also create binding for top level $data
-    // so it can be used in templates too
-    var $dataBinding = compiler.bindings['$data'] = new Binding(compiler, '$data')
-    $dataBinding.update(data)
-
-    // allow $data to be swapped
-    def(compiler.vm, '$data', {
-        get: function () {
-            compiler.observer.emit('get', '$data')
-            return compiler.data
-        },
-        set: function (newData) {
-            var oldData = compiler.data
-            Observer.unobserve(oldData, '', observer)
-            compiler.data = newData
-            Observer.copyPaths(newData, oldData)
-            Observer.observe(newData, '', observer)
-            update()
-        }
-    })
-
-    // emit $data change on all changes
-    observer
-        .on('set', onSet)
-        .on('mutate', onSet)
-
-    function onSet (key) {
-        if (key !== '$data') update()
-    }
-
-    function update () {
-        $dataBinding.update(compiler.data)
-        observer.emit('change:$data', compiler.data)
-    }
-}
-
-/**
- *  Compile a DOM node (recursive)
- */
-CompilerProto.compile = function (node, root) {
-    var nodeType = node.nodeType
-    if (nodeType === 1 && node.tagName !== 'SCRIPT') { // a normal node
-        this.compileElement(node, root)
-    } else if (nodeType === 3 && config.interpolate) {
-        this.compileTextNode(node)
-    }
-}
-
-/**
- *  Check for a priority directive
- *  If it is present and valid, return true to skip the rest
- */
-CompilerProto.checkPriorityDir = function (dirname, node, root) {
-    var expression, directive, Ctor
-    if (
-        dirname === 'component' &&
-        root !== true &&
-        (Ctor = this.resolveComponent(node, undefined, true))
-    ) {
-        directive = this.parseDirective(dirname, '', node)
-        directive.Ctor = Ctor
-    } else {
-        expression = utils.attr(node, dirname)
-        directive = expression && this.parseDirective(dirname, expression, node)
-    }
-    if (directive) {
-        if (root === true) {
-            utils.warn(
-                'Directive v-' + dirname + ' cannot be used on an already instantiated ' +
-                'VM\'s root node. Use it from the parent\'s template instead.'
-            )
-            return
-        }
-        this.deferred.push(directive)
-        return true
-    }
-}
-
-/**
- *  Compile normal directives on a node
- */
-CompilerProto.compileElement = function (node, root) {
-
-    // textarea is pretty annoying
-    // because its value creates childNodes which
-    // we don't want to compile.
-    if (node.tagName === 'TEXTAREA' && node.value) {
-        node.value = this.eval(node.value)
-    }
-
-    // only compile if this element has attributes
-    // or its tagName contains a hyphen (which means it could
-    // potentially be a custom element)
-    if (node.hasAttributes() || node.tagName.indexOf('-') > -1) {
-
-        // skip anything with v-pre
-        if (utils.attr(node, 'pre') !== null) {
-            return
-        }
-
-        var i, l, j, k
-
-        // check priority directives.
-        // if any of them are present, it will take over the node with a childVM
-        // so we can skip the rest
-        for (i = 0, l = priorityDirectives.length; i < l; i++) {
-            if (this.checkPriorityDir(priorityDirectives[i], node, root)) {
-                return
-            }
-        }
-
-        // check transition & animation properties
-        node.vue_trans  = utils.attr(node, 'transition')
-        node.vue_anim   = utils.attr(node, 'animation')
-        node.vue_effect = this.eval(utils.attr(node, 'effect'))
-
-        var prefix = config.prefix + '-',
-            params = this.options.paramAttributes,
-            attr, attrname, isDirective, exp, directives, directive, dirname
-
-        // v-with has special priority among the rest
-        // it needs to pull in the value from the parent before
-        // computed properties are evaluated, because at this stage
-        // the computed properties have not set up their dependencies yet.
-        if (root) {
-            var withExp = utils.attr(node, 'with')
-            if (withExp) {
-                directives = this.parseDirective('with', withExp, node, true)
-                for (j = 0, k = directives.length; j < k; j++) {
-                    this.bindDirective(directives[j], this.parent)
-                }
-            }
-        }
-
-        var attrs = slice.call(node.attributes)
-        for (i = 0, l = attrs.length; i < l; i++) {
-
-            attr = attrs[i]
-            attrname = attr.name
-            isDirective = false
-
-            if (attrname.indexOf(prefix) === 0) {
-                // a directive - split, parse and bind it.
-                isDirective = true
-                dirname = attrname.slice(prefix.length)
-                // build with multiple: true
-                directives = this.parseDirective(dirname, attr.value, node, true)
-                // loop through clauses (separated by ",")
-                // inside each attribute
-                for (j = 0, k = directives.length; j < k; j++) {
-                    this.bindDirective(directives[j])
-                }
-            } else if (config.interpolate) {
-                // non directive attribute, check interpolation tags
-                exp = TextParser.parseAttr(attr.value)
-                if (exp) {
-                    directive = this.parseDirective('attr', exp, node)
-                    directive.arg = attrname
-                    if (params && params.indexOf(attrname) > -1) {
-                        // a param attribute... we should use the parent binding
-                        // to avoid circular updates like size={{size}}
-                        this.bindDirective(directive, this.parent)
-                    } else {
-                        this.bindDirective(directive)
-                    }
-                }
-            }
-
-            if (isDirective && dirname !== 'cloak') {
-                node.removeAttribute(attrname)
-            }
-        }
-
-    }
-
-    // recursively compile childNodes
-    if (node.hasChildNodes()) {
-        slice.call(node.childNodes).forEach(this.compile, this)
-    }
-}
-
-/**
- *  Compile a text node
- */
-CompilerProto.compileTextNode = function (node) {
-
-    var tokens = TextParser.parse(node.nodeValue)
-    if (!tokens) return
-    var el, token, directive
-
-    for (var i = 0, l = tokens.length; i < l; i++) {
-
-        token = tokens[i]
-        directive = null
-
-        if (token.key) { // a binding
-            if (token.key.charAt(0) === '>') { // a partial
-                el = document.createComment('ref')
-                directive = this.parseDirective('partial', token.key.slice(1), el)
-            } else {
-                if (!token.html) { // text binding
-                    el = document.createTextNode('')
-                    directive = this.parseDirective('text', token.key, el)
-                } else { // html binding
-                    el = document.createComment(config.prefix + '-html')
-                    directive = this.parseDirective('html', token.key, el)
-                }
-            }
-        } else { // a plain string
-            el = document.createTextNode(token)
-        }
-
-        // insert node
-        node.parentNode.insertBefore(el, node)
-        // bind directive
-        this.bindDirective(directive)
-
-    }
-    node.parentNode.removeChild(node)
-}
-
-/**
- *  Parse a directive name/value pair into one or more
- *  directive instances
- */
-CompilerProto.parseDirective = function (name, value, el, multiple) {
-    var compiler = this,
-        definition = compiler.getOption('directives', name)
-    if (definition) {
-        // parse into AST-like objects
-        var asts = Directive.parse(value)
-        return multiple
-            ? asts.map(build)
-            : build(asts[0])
-    }
-    function build (ast) {
-        return new Directive(name, ast, definition, compiler, el)
-    }
-}
-
-/**
- *  Add a directive instance to the correct binding & viewmodel
- */
-CompilerProto.bindDirective = function (directive, bindingOwner) {
-
-    if (!directive) return
-
-    // keep track of it so we can unbind() later
-    this.dirs.push(directive)
-
-    // for empty or literal directives, simply call its bind()
-    // and we're done.
-    if (directive.isEmpty || directive.isLiteral) {
-        if (directive.bind) directive.bind()
-        return
-    }
-
-    // otherwise, we got more work to do...
-    var binding,
-        compiler = bindingOwner || this,
-        key      = directive.key
-
-    if (directive.isExp) {
-        // expression bindings are always created on current compiler
-        binding = compiler.createBinding(key, directive)
-    } else {
-        // recursively locate which compiler owns the binding
-        while (compiler) {
-            if (compiler.hasKey(key)) {
-                break
-            } else {
-                compiler = compiler.parent
-            }
-        }
-        compiler = compiler || this
-        binding = compiler.bindings[key] || compiler.createBinding(key)
-    }
-    binding.dirs.push(directive)
-    directive.binding = binding
-
-    var value = binding.val()
-    // invoke bind hook if exists
-    if (directive.bind) {
-        directive.bind(value)
-    }
-    // set initial value
-    directive.$update(value, true)
-}
-
-/**
- *  Create binding and attach getter/setter for a key to the viewmodel object
- */
-CompilerProto.createBinding = function (key, directive) {
-
-    utils.log('  created binding: ' + key)
-
-    var compiler = this,
-        methods  = compiler.options.methods,
-        isExp    = directive && directive.isExp,
-        isFn     = (directive && directive.isFn) || (methods && methods[key]),
-        bindings = compiler.bindings,
-        computed = compiler.options.computed,
-        binding  = new Binding(compiler, key, isExp, isFn)
-
-    if (isExp) {
-        // expression bindings are anonymous
-        compiler.defineExp(key, binding, directive)
-    } else if (isFn) {
-        bindings[key] = binding
-        compiler.defineVmProp(key, binding, methods[key])
-    } else {
-        bindings[key] = binding
-        if (binding.root) {
-            // this is a root level binding. we need to define getter/setters for it.
-            if (computed && computed[key]) {
-                // computed property
-                compiler.defineComputed(key, binding, computed[key])
-            } else if (key.charAt(0) !== '$') {
-                // normal property
-                compiler.defineDataProp(key, binding)
-            } else {
-                // properties that start with $ are meta properties
-                // they should be kept on the vm but not in the data object.
-                compiler.defineVmProp(key, binding, compiler.data[key])
-                delete compiler.data[key]
-            }
-        } else if (computed && computed[utils.baseKey(key)]) {
-            // nested path on computed property
-            compiler.defineExp(key, binding)
-        } else {
-            // ensure path in data so that computed properties that
-            // access the path don't throw an error and can collect
-            // dependencies
-            Observer.ensurePath(compiler.data, key)
-            var parentKey = key.slice(0, key.lastIndexOf('.'))
-            if (!bindings[parentKey]) {
-                // this is a nested value binding, but the binding for its parent
-                // has not been created yet. We better create that one too.
-                compiler.createBinding(parentKey)
-            }
-        }
-    }
-    return binding
-}
-
-/**
- *  Define the getter/setter to proxy a root-level
- *  data property on the VM
- */
-CompilerProto.defineDataProp = function (key, binding) {
-    var compiler = this,
-        data     = compiler.data,
-        ob       = data.__emitter__
-
-    // make sure the key is present in data
-    // so it can be observed
-    if (!(hasOwn.call(data, key))) {
-        data[key] = undefined
-    }
-
-    // if the data object is already observed, but the key
-    // is not observed, we need to add it to the observed keys.
-    if (ob && !(hasOwn.call(ob.values, key))) {
-        Observer.convertKey(data, key)
-    }
-
-    binding.value = data[key]
-
-    def(compiler.vm, key, {
-        get: function () {
-            return compiler.data[key]
-        },
-        set: function (val) {
-            compiler.data[key] = val
-        }
-    })
-}
-
-/**
- *  Define a vm property, e.g. $index, $key, or mixin methods
- *  which are bindable but only accessible on the VM,
- *  not in the data.
- */
-CompilerProto.defineVmProp = function (key, binding, value) {
-    var ob = this.observer
-    binding.value = value
-    def(this.vm, key, {
-        get: function () {
-            if (Observer.shouldGet) ob.emit('get', key)
-            return binding.value
-        },
-        set: function (val) {
-            ob.emit('set', key, val)
-        }
-    })
-}
-
-/**
- *  Define an expression binding, which is essentially
- *  an anonymous computed property
- */
-CompilerProto.defineExp = function (key, binding, directive) {
-    var computedKey = directive && directive.computedKey,
-        exp         = computedKey ? directive.expression : key,
-        getter      = this.expCache[exp]
-    if (!getter) {
-        getter = this.expCache[exp] = ExpParser.parse(computedKey || key, this)
-    }
-    if (getter) {
-        this.markComputed(binding, getter)
-    }
-}
-
-/**
- *  Define a computed property on the VM
- */
-CompilerProto.defineComputed = function (key, binding, value) {
-    this.markComputed(binding, value)
-    def(this.vm, key, {
-        get: binding.value.$get,
-        set: binding.value.$set
-    })
-}
-
-/**
- *  Process a computed property binding
- *  so its getter/setter are bound to proper context
- */
-CompilerProto.markComputed = function (binding, value) {
-    binding.isComputed = true
-    // bind the accessors to the vm
-    if (binding.isFn) {
-        binding.value = value
-    } else {
-        if (typeof value === 'function') {
-            value = { $get: value }
-        }
-        binding.value = {
-            $get: utils.bind(value.$get, this.vm),
-            $set: value.$set
-                ? utils.bind(value.$set, this.vm)
-                : undefined
-        }
-    }
-    // keep track for dep parsing later
-    this.computed.push(binding)
-}
-
-/**
- *  Retrive an option from the compiler
- */
-CompilerProto.getOption = function (type, id, silent) {
-    var opts = this.options,
-        parent = this.parent,
-        globalAssets = config.globalAssets,
-        res = (opts[type] && opts[type][id]) || (
-            parent
-                ? parent.getOption(type, id, silent)
-                : globalAssets[type] && globalAssets[type][id]
-        )
-    if (!res && !silent && typeof id === 'string') {
-        utils.warn('Unknown ' + type.slice(0, -1) + ': ' + id)
-    }
-    return res
-}
-
-/**
- *  Emit lifecycle events to trigger hooks
- */
-CompilerProto.execHook = function (event) {
-    event = 'hook:' + event
-    this.observer.emit(event)
-    this.emitter.emit(event)
-}
-
-/**
- *  Check if a compiler's data contains a keypath
- */
-CompilerProto.hasKey = function (key) {
-    var baseKey = utils.baseKey(key)
-    return hasOwn.call(this.data, baseKey) ||
-        hasOwn.call(this.vm, baseKey)
-}
-
-/**
- *  Do a one-time eval of a string that potentially
- *  includes bindings. It accepts additional raw data
- *  because we need to dynamically resolve v-component
- *  before a childVM is even compiled...
- */
-CompilerProto.eval = function (exp, data) {
-    var parsed = TextParser.parseAttr(exp)
-    return parsed
-        ? ExpParser.eval(parsed, this, data)
-        : exp
-}
-
-/**
- *  Resolve a Component constructor for an element
- *  with the data to be used
- */
-CompilerProto.resolveComponent = function (node, data, test) {
-
-    // late require to avoid circular deps
-    ViewModel = ViewModel || require('./viewmodel')
-
-    var exp     = utils.attr(node, 'component'),
-        tagName = node.tagName,
-        id      = this.eval(exp, data),
-        tagId   = (tagName.indexOf('-') > 0 && tagName.toLowerCase()),
-        Ctor    = this.getOption('components', id || tagId, true)
-
-    if (id && !Ctor) {
-        utils.warn('Unknown component: ' + id)
-    }
-
-    return test
-        ? exp === ''
-            ? ViewModel
-            : Ctor
-        : Ctor || ViewModel
-}
-
-/**
- *  Unbind and remove element
- */
-CompilerProto.destroy = function (noRemove) {
-
-    // avoid being called more than once
-    // this is irreversible!
-    if (this.destroyed) return
-
-    var compiler = this,
-        i, j, key, dir, dirs, binding,
-        vm          = compiler.vm,
-        el          = compiler.el,
-        directives  = compiler.dirs,
-        computed    = compiler.computed,
-        bindings    = compiler.bindings,
-        children    = compiler.children,
-        parent      = compiler.parent
-
-    compiler.execHook('beforeDestroy')
-
-    // unobserve data
-    Observer.unobserve(compiler.data, '', compiler.observer)
-
-    // destroy all children
-    // do not remove their elements since the parent
-    // may have transitions and the children may not
-    i = children.length
-    while (i--) {
-        children[i].destroy(true)
-    }
-
-    // unbind all direcitves
-    i = directives.length
-    while (i--) {
-        dir = directives[i]
-        // if this directive is an instance of an external binding
-        // e.g. a directive that refers to a variable on the parent VM
-        // we need to remove it from that binding's directives
-        // * empty and literal bindings do not have binding.
-        if (dir.binding && dir.binding.compiler !== compiler) {
-            dirs = dir.binding.dirs
-            if (dirs) {
-                j = dirs.indexOf(dir)
-                if (j > -1) dirs.splice(j, 1)
-            }
-        }
-        dir.$unbind()
-    }
-
-    // unbind all computed, anonymous bindings
-    i = computed.length
-    while (i--) {
-        computed[i].unbind()
-    }
-
-    // unbind all keypath bindings
-    for (key in bindings) {
-        binding = bindings[key]
-        if (binding) {
-            binding.unbind()
-        }
-    }
-
-    // remove self from parent
-    if (parent) {
-        j = parent.children.indexOf(compiler)
-        if (j > -1) parent.children.splice(j, 1)
-    }
-
-    // finally remove dom element
-    if (!noRemove) {
-        if (el === document.body) {
-            el.innerHTML = ''
-        } else {
-            vm.$remove()
-        }
-    }
-    el.vue_vm = null
-
-    compiler.destroyed = true
-    // emit destroy hook
-    compiler.execHook('afterDestroy')
-
-    // finally, unregister all listeners
-    compiler.observer.off()
-    compiler.emitter.off()
-}
-
-// Helpers --------------------------------------------------------------------
-
-/**
- *  shorthand for getting root compiler
- */
-function getRoot (compiler) {
-    while (compiler.parent) {
-        compiler = compiler.parent
-    }
-    return compiler
-}
-
-module.exports = Compiler
-});
-require.register("vue/src/viewmodel.js", function(exports, require, module){
-var Compiler   = require('./compiler'),
-    utils      = require('./utils'),
-    transition = require('./transition'),
-    Batcher    = require('./batcher'),
-    slice      = [].slice,
-    def        = utils.defProtected,
-    nextTick   = utils.nextTick,
-
-    // batch $watch callbacks
-    watcherBatcher = new Batcher(),
-    watcherId      = 1
-
-/**
- *  ViewModel exposed to the user that holds data,
- *  computed properties, event handlers
- *  and a few reserved methods
- */
-function ViewModel (options) {
-    // compile if options passed, if false return. options are passed directly to compiler
-    if (options === false) return
-    new Compiler(this, options)
-}
-
-// All VM prototype methods are inenumerable
-// so it can be stringified/looped through as raw data
-var VMProto = ViewModel.prototype
-
-/**
- *  init allows config compilation after instantiation:
- *    var a = new Vue(false)
- *    a.init(config)
- */
-def(VMProto, '$init', function (options) {
-    new Compiler(this, options)
-})
-
-/**
- *  Convenience function to get a value from
- *  a keypath
- */
-def(VMProto, '$get', function (key) {
-    var val = utils.get(this, key)
-    return val === undefined && this.$parent
-        ? this.$parent.$get(key)
-        : val
-})
-
-/**
- *  Convenience function to set an actual nested value
- *  from a flat key string. Used in directives.
- */
-def(VMProto, '$set', function (key, value) {
-    utils.set(this, key, value)
-})
-
-/**
- *  watch a key on the viewmodel for changes
- *  fire callback with new value
- */
-def(VMProto, '$watch', function (key, callback) {
-    // save a unique id for each watcher
-    var id = watcherId++,
-        self = this
-    function on () {
-        var args = slice.call(arguments)
-        watcherBatcher.push({
-            id: id,
-            override: true,
-            execute: function () {
-                callback.apply(self, args)
-            }
-        })
-    }
-    callback._fn = on
-    self.$compiler.observer.on('change:' + key, on)
-})
-
-/**
- *  unwatch a key
- */
-def(VMProto, '$unwatch', function (key, callback) {
-    // workaround here
-    // since the emitter module checks callback existence
-    // by checking the length of arguments
-    var args = ['change:' + key],
-        ob = this.$compiler.observer
-    if (callback) args.push(callback._fn)
-    ob.off.apply(ob, args)
-})
-
-/**
- *  unbind everything, remove everything
- */
-def(VMProto, '$destroy', function (noRemove) {
-    this.$compiler.destroy(noRemove)
-})
-
-/**
- *  broadcast an event to all child VMs recursively.
- */
-def(VMProto, '$broadcast', function () {
-    var children = this.$compiler.children,
-        i = children.length,
-        child
-    while (i--) {
-        child = children[i]
-        child.emitter.applyEmit.apply(child.emitter, arguments)
-        child.vm.$broadcast.apply(child.vm, arguments)
-    }
-})
-
-/**
- *  emit an event that propagates all the way up to parent VMs.
- */
-def(VMProto, '$dispatch', function () {
-    var compiler = this.$compiler,
-        emitter = compiler.emitter,
-        parent = compiler.parent
-    emitter.applyEmit.apply(emitter, arguments)
-    if (parent) {
-        parent.vm.$dispatch.apply(parent.vm, arguments)
-    }
-})
-
-/**
- *  delegate on/off/once to the compiler's emitter
- */
-;['emit', 'on', 'off', 'once'].forEach(function (method) {
-    // internal emit has fixed number of arguments.
-    // exposed emit uses the external version
-    // with fn.apply.
-    var realMethod = method === 'emit'
-        ? 'applyEmit'
-        : method
-    def(VMProto, '$' + method, function () {
-        var emitter = this.$compiler.emitter
-        emitter[realMethod].apply(emitter, arguments)
-    })
-})
-
-// DOM convenience methods
-
-def(VMProto, '$appendTo', function (target, cb) {
-    target = query(target)
-    var el = this.$el
-    transition(el, 1, function () {
-        target.appendChild(el)
-        if (cb) nextTick(cb)
-    }, this.$compiler)
-})
-
-def(VMProto, '$remove', function (cb) {
-    var el = this.$el
-    transition(el, -1, function () {
-        if (el.parentNode) {
-            el.parentNode.removeChild(el)
-        }
-        if (cb) nextTick(cb)
-    }, this.$compiler)
-})
-
-def(VMProto, '$before', function (target, cb) {
-    target = query(target)
-    var el = this.$el
-    transition(el, 1, function () {
-        target.parentNode.insertBefore(el, target)
-        if (cb) nextTick(cb)
-    }, this.$compiler)
-})
-
-def(VMProto, '$after', function (target, cb) {
-    target = query(target)
-    var el = this.$el
-    transition(el, 1, function () {
-        if (target.nextSibling) {
-            target.parentNode.insertBefore(el, target.nextSibling)
-        } else {
-            target.parentNode.appendChild(el)
-        }
-        if (cb) nextTick(cb)
-    }, this.$compiler)
-})
-
-function query (el) {
-    return typeof el === 'string'
-        ? document.querySelector(el)
-        : el
-}
-
-module.exports = ViewModel
-
-});
-require.register("vue/src/binding.js", function(exports, require, module){
-var Batcher        = require('./batcher'),
-    bindingBatcher = new Batcher(),
-    bindingId      = 1
-
-/**
- *  Binding class.
- *
- *  each property on the viewmodel has one corresponding Binding object
- *  which has multiple directive instances on the DOM
- *  and multiple computed property dependents
- */
-function Binding (compiler, key, isExp, isFn) {
-    this.id = bindingId++
-    this.value = undefined
-    this.isExp = !!isExp
-    this.isFn = isFn
-    this.root = !this.isExp && key.indexOf('.') === -1
-    this.compiler = compiler
-    this.key = key
-    this.dirs = []
-    this.subs = []
-    this.deps = []
-    this.unbound = false
-}
-
-var BindingProto = Binding.prototype
-
-/**
- *  Update value and queue instance updates.
- */
-BindingProto.update = function (value) {
-    if (!this.isComputed || this.isFn) {
-        this.value = value
-    }
-    if (this.dirs.length || this.subs.length) {
-        var self = this
-        bindingBatcher.push({
-            id: this.id,
-            execute: function () {
-                if (!self.unbound) {
-                    self._update()
-                }
-            }
-        })
-    }
-}
-
-/**
- *  Actually update the directives.
- */
-BindingProto._update = function () {
-    var i = this.dirs.length,
-        value = this.val()
-    while (i--) {
-        this.dirs[i].$update(value)
-    }
-    this.pub()
-}
-
-/**
- *  Return the valuated value regardless
- *  of whether it is computed or not
- */
-BindingProto.val = function () {
-    return this.isComputed && !this.isFn
-        ? this.value.$get()
-        : this.value
-}
-
-/**
- *  Notify computed properties that depend on this binding
- *  to update themselves
- */
-BindingProto.pub = function () {
-    var i = this.subs.length
-    while (i--) {
-        this.subs[i].update()
-    }
-}
-
-/**
- *  Unbind the binding, remove itself from all of its dependencies
- */
-BindingProto.unbind = function () {
-    // Indicate this has been unbound.
-    // It's possible this binding will be in
-    // the batcher's flush queue when its owner
-    // compiler has already been destroyed.
-    this.unbound = true
-    var i = this.dirs.length
-    while (i--) {
-        this.dirs[i].$unbind()
-    }
-    i = this.deps.length
-    var subs
-    while (i--) {
-        subs = this.deps[i].subs
-        var j = subs.indexOf(this)
-        if (j > -1) subs.splice(j, 1)
-    }
-}
-
-module.exports = Binding
-});
-require.register("vue/src/observer.js", function(exports, require, module){
-/* jshint proto:true */
-
-var Emitter  = require('./emitter'),
-    utils    = require('./utils'),
-    // cache methods
-    def      = utils.defProtected,
-    isObject = utils.isObject,
-    isArray  = Array.isArray,
-    hasOwn   = ({}).hasOwnProperty,
-    oDef     = Object.defineProperty,
-    slice    = [].slice,
-    // fix for IE + __proto__ problem
-    // define methods as inenumerable if __proto__ is present,
-    // otherwise enumerable so we can loop through and manually
-    // attach to array instances
-    hasProto = ({}).__proto__
-
-// Array Mutation Handlers & Augmentations ------------------------------------
-
-// The proxy prototype to replace the __proto__ of
-// an observed array
-var ArrayProxy = Object.create(Array.prototype)
-
-// intercept mutation methods
-;[
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
-].forEach(watchMutation)
-
-// Augment the ArrayProxy with convenience methods
-def(ArrayProxy, '$set', function (index, data) {
-    return this.splice(index, 1, data)[0]
-}, !hasProto)
-
-def(ArrayProxy, '$remove', function (index) {
-    if (typeof index !== 'number') {
-        index = this.indexOf(index)
-    }
-    if (index > -1) {
-        return this.splice(index, 1)[0]
-    }
-}, !hasProto)
-
-/**
- *  Intercep a mutation event so we can emit the mutation info.
- *  we also analyze what elements are added/removed and link/unlink
- *  them with the parent Array.
- */
-function watchMutation (method) {
-    def(ArrayProxy, method, function () {
-
-        var args = slice.call(arguments),
-            result = Array.prototype[method].apply(this, args),
-            inserted, removed
-
-        // determine new / removed elements
-        if (method === 'push' || method === 'unshift') {
-            inserted = args
-        } else if (method === 'pop' || method === 'shift') {
-            removed = [result]
-        } else if (method === 'splice') {
-            inserted = args.slice(2)
-            removed = result
-        }
-        
-        // link & unlink
-        linkArrayElements(this, inserted)
-        unlinkArrayElements(this, removed)
-
-        // emit the mutation event
-        this.__emitter__.emit('mutate', '', this, {
-            method   : method,
-            args     : args,
-            result   : result,
-            inserted : inserted,
-            removed  : removed
-        })
-
-        return result
-        
-    }, !hasProto)
-}
-
-/**
- *  Link new elements to an Array, so when they change
- *  and emit events, the owner Array can be notified.
- */
-function linkArrayElements (arr, items) {
-    if (items) {
-        var i = items.length, item, owners
-        while (i--) {
-            item = items[i]
-            if (isWatchable(item)) {
-                // if object is not converted for observing
-                // convert it...
-                if (!item.__emitter__) {
-                    convert(item)
-                    watch(item)
-                }
-                owners = item.__emitter__.owners
-                if (owners.indexOf(arr) < 0) {
-                    owners.push(arr)
-                }
-            }
-        }
-    }
-}
-
-/**
- *  Unlink removed elements from the ex-owner Array.
- */
-function unlinkArrayElements (arr, items) {
-    if (items) {
-        var i = items.length, item
-        while (i--) {
-            item = items[i]
-            if (item && item.__emitter__) {
-                var owners = item.__emitter__.owners
-                if (owners) owners.splice(owners.indexOf(arr))
-            }
-        }
-    }
-}
-
-// Object add/delete key augmentation -----------------------------------------
-
-var ObjProxy = Object.create(Object.prototype)
-
-def(ObjProxy, '$add', function (key, val) {
-    if (hasOwn.call(this, key)) return
-    this[key] = val
-    convertKey(this, key, true)
-}, !hasProto)
-
-def(ObjProxy, '$delete', function (key) {
-    if (!(hasOwn.call(this, key))) return
-    // trigger set events
-    this[key] = undefined
-    delete this[key]
-    this.__emitter__.emit('delete', key)
-}, !hasProto)
-
-// Watch Helpers --------------------------------------------------------------
-
-/**
- *  Check if a value is watchable
- */
-function isWatchable (obj) {
-    return typeof obj === 'object' && obj && !obj.$compiler
-}
-
-/**
- *  Convert an Object/Array to give it a change emitter.
- */
-function convert (obj) {
-    if (obj.__emitter__) return true
-    var emitter = new Emitter()
-    def(obj, '__emitter__', emitter)
-    emitter
-        .on('set', function (key, val, propagate) {
-            if (propagate) propagateChange(obj)
-        })
-        .on('mutate', function () {
-            propagateChange(obj)
-        })
-    emitter.values = utils.hash()
-    emitter.owners = []
-    return false
-}
-
-/**
- *  Propagate an array element's change to its owner arrays
- */
-function propagateChange (obj) {
-    var owners = obj.__emitter__.owners,
-        i = owners.length
-    while (i--) {
-        owners[i].__emitter__.emit('set', '', '', true)
-    }
-}
-
-/**
- *  Watch target based on its type
- */
-function watch (obj) {
-    if (isArray(obj)) {
-        watchArray(obj)
-    } else {
-        watchObject(obj)
-    }
-}
-
-/**
- *  Augment target objects with modified
- *  methods
- */
-function augment (target, src) {
-    if (hasProto) {
-        target.__proto__ = src
-    } else {
-        for (var key in src) {
-            def(target, key, src[key])
-        }
-    }
-}
-
-/**
- *  Watch an Object, recursive.
- */
-function watchObject (obj) {
-    augment(obj, ObjProxy)
-    for (var key in obj) {
-        convertKey(obj, key)
-    }
-}
-
-/**
- *  Watch an Array, overload mutation methods
- *  and add augmentations by intercepting the prototype chain
- */
-function watchArray (arr) {
-    augment(arr, ArrayProxy)
-    linkArrayElements(arr, arr)
-}
-
-/**
- *  Define accessors for a property on an Object
- *  so it emits get/set events.
- *  Then watch the value itself.
- */
-function convertKey (obj, key, propagate) {
-    var keyPrefix = key.charAt(0)
-    if (keyPrefix === '$' || keyPrefix === '_') {
-        return
-    }
-    // emit set on bind
-    // this means when an object is observed it will emit
-    // a first batch of set events.
-    var emitter = obj.__emitter__,
-        values  = emitter.values
-
-    init(obj[key], propagate)
-
-    oDef(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function () {
-            var value = values[key]
-            // only emit get on tip values
-            if (pub.shouldGet) {
-                emitter.emit('get', key)
-            }
-            return value
-        },
-        set: function (newVal) {
-            var oldVal = values[key]
-            unobserve(oldVal, key, emitter)
-            copyPaths(newVal, oldVal)
-            // an immediate property should notify its parent
-            // to emit set for itself too
-            init(newVal, true)
-        }
-    })
-
-    function init (val, propagate) {
-        values[key] = val
-        emitter.emit('set', key, val, propagate)
-        if (isArray(val)) {
-            emitter.emit('set', key + '.length', val.length, propagate)
-        }
-        observe(val, key, emitter)
-    }
-}
-
-/**
- *  When a value that is already converted is
- *  observed again by another observer, we can skip
- *  the watch conversion and simply emit set event for
- *  all of its properties.
- */
-function emitSet (obj) {
-    var emitter = obj && obj.__emitter__
-    if (!emitter) return
-    if (isArray(obj)) {
-        emitter.emit('set', 'length', obj.length)
-    } else {
-        var key, val
-        for (key in obj) {
-            val = obj[key]
-            emitter.emit('set', key, val)
-            emitSet(val)
-        }
-    }
-}
-
-/**
- *  Make sure all the paths in an old object exists
- *  in a new object.
- *  So when an object changes, all missing keys will
- *  emit a set event with undefined value.
- */
-function copyPaths (newObj, oldObj) {
-    if (!isObject(newObj) || !isObject(oldObj)) {
-        return
-    }
-    var path, oldVal, newVal
-    for (path in oldObj) {
-        if (!(hasOwn.call(newObj, path))) {
-            oldVal = oldObj[path]
-            if (isArray(oldVal)) {
-                newObj[path] = []
-            } else if (isObject(oldVal)) {
-                newVal = newObj[path] = {}
-                copyPaths(newVal, oldVal)
-            } else {
-                newObj[path] = undefined
-            }
-        }
-    }
-}
-
-/**
- *  walk along a path and make sure it can be accessed
- *  and enumerated in that object
- */
-function ensurePath (obj, key) {
-    var path = key.split('.'), sec
-    for (var i = 0, d = path.length - 1; i < d; i++) {
-        sec = path[i]
-        if (!obj[sec]) {
-            obj[sec] = {}
-            if (obj.__emitter__) convertKey(obj, sec)
-        }
-        obj = obj[sec]
-    }
-    if (isObject(obj)) {
-        sec = path[i]
-        if (!(hasOwn.call(obj, sec))) {
-            obj[sec] = undefined
-            if (obj.__emitter__) convertKey(obj, sec)
-        }
-    }
-}
-
-// Main API Methods -----------------------------------------------------------
-
-/**
- *  Observe an object with a given path,
- *  and proxy get/set/mutate events to the provided observer.
- */
-function observe (obj, rawPath, observer) {
-
-    if (!isWatchable(obj)) return
-
-    var path = rawPath ? rawPath + '.' : '',
-        alreadyConverted = convert(obj),
-        emitter = obj.__emitter__
-
-    // setup proxy listeners on the parent observer.
-    // we need to keep reference to them so that they
-    // can be removed when the object is un-observed.
-    observer.proxies = observer.proxies || {}
-    var proxies = observer.proxies[path] = {
-        get: function (key) {
-            observer.emit('get', path + key)
-        },
-        set: function (key, val, propagate) {
-            if (key) observer.emit('set', path + key, val)
-            // also notify observer that the object itself changed
-            // but only do so when it's a immediate property. this
-            // avoids duplicate event firing.
-            if (rawPath && propagate) {
-                observer.emit('set', rawPath, obj, true)
-            }
-        },
-        mutate: function (key, val, mutation) {
-            // if the Array is a root value
-            // the key will be null
-            var fixedPath = key ? path + key : rawPath
-            observer.emit('mutate', fixedPath, val, mutation)
-            // also emit set for Array's length when it mutates
-            var m = mutation.method
-            if (m !== 'sort' && m !== 'reverse') {
-                observer.emit('set', fixedPath + '.length', val.length)
-            }
-        }
-    }
-
-    // attach the listeners to the child observer.
-    // now all the events will propagate upwards.
-    emitter
-        .on('get', proxies.get)
-        .on('set', proxies.set)
-        .on('mutate', proxies.mutate)
-
-    if (alreadyConverted) {
-        // for objects that have already been converted,
-        // emit set events for everything inside
-        emitSet(obj)
-    } else {
-        watch(obj)
-    }
-}
-
-/**
- *  Cancel observation, turn off the listeners.
- */
-function unobserve (obj, path, observer) {
-
-    if (!obj || !obj.__emitter__) return
-
-    path = path ? path + '.' : ''
-    var proxies = observer.proxies[path]
-    if (!proxies) return
-
-    // turn off listeners
-    obj.__emitter__
-        .off('get', proxies.get)
-        .off('set', proxies.set)
-        .off('mutate', proxies.mutate)
-
-    // remove reference
-    observer.proxies[path] = null
-}
-
-// Expose API -----------------------------------------------------------------
-
-var pub = module.exports = {
-
-    // whether to emit get events
-    // only enabled during dependency parsing
-    shouldGet   : false,
-
-    observe     : observe,
-    unobserve   : unobserve,
-    ensurePath  : ensurePath,
-    copyPaths   : copyPaths,
-    watch       : watch,
-    convert     : convert,
-    convertKey  : convertKey
-}
-});
-require.register("vue/src/directive.js", function(exports, require, module){
-var dirId           = 1,
-    ARG_RE          = /^[\w\$-]+$/,
-    FILTER_TOKEN_RE = /[^\s'"]+|'[^']+'|"[^"]+"/g,
-    NESTING_RE      = /^\$(parent|root)\./,
-    SINGLE_VAR_RE   = /^[\w\.$]+$/,
-    QUOTE_RE        = /"/g,
-    TextParser      = require('./text-parser')
-
-/**
- *  Directive class
- *  represents a single directive instance in the DOM
- */
-function Directive (name, ast, definition, compiler, el) {
-
-    this.id             = dirId++
-    this.name           = name
-    this.compiler       = compiler
-    this.vm             = compiler.vm
-    this.el             = el
-    this.computeFilters = false
-    this.key            = ast.key
-    this.arg            = ast.arg
-    this.expression     = ast.expression
-
-    var isEmpty = this.expression === ''
-
-    // mix in properties from the directive definition
-    if (typeof definition === 'function') {
-        this[isEmpty ? 'bind' : 'update'] = definition
-    } else {
-        for (var prop in definition) {
-            this[prop] = definition[prop]
-        }
-    }
-
-    // empty expression, we're done.
-    if (isEmpty || this.isEmpty) {
-        this.isEmpty = true
-        return
-    }
-
-    if (TextParser.Regex.test(this.key)) {
-        this.key = compiler.eval(this.key)
-        if (this.isLiteral) {
-            this.expression = this.key
-        }
-    }
-
-    var filters = ast.filters,
-        filter, fn, i, l, computed
-    if (filters) {
-        this.filters = []
-        for (i = 0, l = filters.length; i < l; i++) {
-            filter = filters[i]
-            fn = this.compiler.getOption('filters', filter.name)
-            if (fn) {
-                filter.apply = fn
-                this.filters.push(filter)
-                if (fn.computed) {
-                    computed = true
-                }
-            }
-        }
-    }
-
-    if (!this.filters || !this.filters.length) {
-        this.filters = null
-    }
-
-    if (computed) {
-        this.computedKey = Directive.inlineFilters(this.key, this.filters)
-        this.filters = null
-    }
-
-    this.isExp =
-        computed ||
-        !SINGLE_VAR_RE.test(this.key) ||
-        NESTING_RE.test(this.key)
-
-}
-
-var DirProto = Directive.prototype
-
-/**
- *  called when a new value is set 
- *  for computed properties, this will only be called once
- *  during initialization.
- */
-DirProto.$update = function (value, init) {
-    if (this.$lock) return
-    if (init || value !== this.value || (value && typeof value === 'object')) {
-        this.value = value
-        if (this.update) {
-            this.update(
-                this.filters && !this.computeFilters
-                    ? this.$applyFilters(value)
-                    : value,
-                init
-            )
-        }
-    }
-}
-
-/**
- *  pipe the value through filters
- */
-DirProto.$applyFilters = function (value) {
-    var filtered = value, filter
-    for (var i = 0, l = this.filters.length; i < l; i++) {
-        filter = this.filters[i]
-        filtered = filter.apply.apply(this.vm, [filtered].concat(filter.args))
-    }
-    return filtered
-}
-
-/**
- *  Unbind diretive
- */
-DirProto.$unbind = function () {
-    // this can be called before the el is even assigned...
-    if (!this.el || !this.vm) return
-    if (this.unbind) this.unbind()
-    this.vm = this.el = this.binding = this.compiler = null
-}
-
-// Exposed static methods -----------------------------------------------------
-
-/**
- *  Parse a directive string into an Array of
- *  AST-like objects representing directives
- */
-Directive.parse = function (str) {
-
-    var inSingle = false,
-        inDouble = false,
-        curly    = 0,
-        square   = 0,
-        paren    = 0,
-        begin    = 0,
-        argIndex = 0,
-        dirs     = [],
-        dir      = {},
-        lastFilterIndex = 0,
-        arg
-
-    for (var c, i = 0, l = str.length; i < l; i++) {
-        c = str.charAt(i)
-        if (inSingle) {
-            // check single quote
-            if (c === "'") inSingle = !inSingle
-        } else if (inDouble) {
-            // check double quote
-            if (c === '"') inDouble = !inDouble
-        } else if (c === ',' && !paren && !curly && !square) {
-            // reached the end of a directive
-            pushDir()
-            // reset & skip the comma
-            dir = {}
-            begin = argIndex = lastFilterIndex = i + 1
-        } else if (c === ':' && !dir.key && !dir.arg) {
-            // argument
-            arg = str.slice(begin, i).trim()
-            if (ARG_RE.test(arg)) {
-                argIndex = i + 1
-                dir.arg = arg
-            }
-        } else if (c === '|' && str.charAt(i + 1) !== '|' && str.charAt(i - 1) !== '|') {
-            if (dir.key === undefined) {
-                // first filter, end of key
-                lastFilterIndex = i + 1
-                dir.key = str.slice(argIndex, i).trim()
-            } else {
-                // already has filter
-                pushFilter()
-            }
-        } else if (c === '"') {
-            inDouble = true
-        } else if (c === "'") {
-            inSingle = true
-        } else if (c === '(') {
-            paren++
-        } else if (c === ')') {
-            paren--
-        } else if (c === '[') {
-            square++
-        } else if (c === ']') {
-            square--
-        } else if (c === '{') {
-            curly++
-        } else if (c === '}') {
-            curly--
-        }
-    }
-    if (i === 0 || begin !== i) {
-        pushDir()
-    }
-
-    function pushDir () {
-        dir.expression = str.slice(begin, i).trim()
-        if (dir.key === undefined) {
-            dir.key = str.slice(argIndex, i).trim()
-        } else if (lastFilterIndex !== begin) {
-            pushFilter()
-        }
-        if (i === 0 || dir.key) {
-            dirs.push(dir)
-        }
-    }
-
-    function pushFilter () {
-        var exp = str.slice(lastFilterIndex, i).trim(),
-            filter
-        if (exp) {
-            filter = {}
-            var tokens = exp.match(FILTER_TOKEN_RE)
-            filter.name = tokens[0]
-            filter.args = tokens.length > 1 ? tokens.slice(1) : null
-        }
-        if (filter) {
-            (dir.filters = dir.filters || []).push(filter)
-        }
-        lastFilterIndex = i + 1
-    }
-
-    return dirs
-}
-
-/**
- *  Inline computed filters so they become part
- *  of the expression
- */
-Directive.inlineFilters = function (key, filters) {
-    var args, filter
-    for (var i = 0, l = filters.length; i < l; i++) {
-        filter = filters[i]
-        args = filter.args
-            ? ',"' + filter.args.map(escapeQuote).join('","') + '"'
-            : ''
-        key = 'this.$compiler.getOption("filters", "' +
-                filter.name +
-            '").call(this,' +
-                key + args +
-            ')'
-    }
-    return key
-}
-
-/**
- *  Convert double quotes to single quotes
- *  so they don't mess up the generated function body
- */
-function escapeQuote (v) {
-    return v.indexOf('"') > -1
-        ? v.replace(QUOTE_RE, '\'')
-        : v
-}
-
-module.exports = Directive
-});
-require.register("vue/src/exp-parser.js", function(exports, require, module){
-var utils           = require('./utils'),
-    STR_SAVE_RE     = /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g,
-    STR_RESTORE_RE  = /"(\d+)"/g,
-    NEWLINE_RE      = /\n/g,
-    CTOR_RE         = new RegExp('constructor'.split('').join('[\'"+, ]*')),
-    UNICODE_RE      = /\\u\d\d\d\d/
-
-// Variable extraction scooped from https://github.com/RubyLouvre/avalon
-
-var KEYWORDS =
-        // keywords
-        'break,case,catch,continue,debugger,default,delete,do,else,false' +
-        ',finally,for,function,if,in,instanceof,new,null,return,switch,this' +
-        ',throw,true,try,typeof,var,void,while,with,undefined' +
-        // reserved
-        ',abstract,boolean,byte,char,class,const,double,enum,export,extends' +
-        ',final,float,goto,implements,import,int,interface,long,native' +
-        ',package,private,protected,public,short,static,super,synchronized' +
-        ',throws,transient,volatile' +
-        // ECMA 5 - use strict
-        ',arguments,let,yield' +
-        // allow using Math in expressions
-        ',Math',
-        
-    KEYWORDS_RE = new RegExp(["\\b" + KEYWORDS.replace(/,/g, '\\b|\\b') + "\\b"].join('|'), 'g'),
-    REMOVE_RE   = /\/\*(?:.|\n)*?\*\/|\/\/[^\n]*\n|\/\/[^\n]*$|'[^']*'|"[^"]*"|[\s\t\n]*\.[\s\t\n]*[$\w\.]+|[\{,]\s*[\w\$_]+\s*:/g,
-    SPLIT_RE    = /[^\w$]+/g,
-    NUMBER_RE   = /\b\d[^,]*/g,
-    BOUNDARY_RE = /^,+|,+$/g
-
-/**
- *  Strip top level variable names from a snippet of JS expression
- */
-function getVariables (code) {
-    code = code
-        .replace(REMOVE_RE, '')
-        .replace(SPLIT_RE, ',')
-        .replace(KEYWORDS_RE, '')
-        .replace(NUMBER_RE, '')
-        .replace(BOUNDARY_RE, '')
-    return code
-        ? code.split(/,+/)
-        : []
-}
-
-/**
- *  A given path could potentially exist not on the
- *  current compiler, but up in the parent chain somewhere.
- *  This function generates an access relationship string
- *  that can be used in the getter function by walking up
- *  the parent chain to check for key existence.
- *
- *  It stops at top parent if no vm in the chain has the
- *  key. It then creates any missing bindings on the
- *  final resolved vm.
- */
-function traceScope (path, compiler, data) {
-    var rel  = '',
-        dist = 0,
-        self = compiler
-
-    if (data && utils.get(data, path) !== undefined) {
-        // hack: temporarily attached data
-        return '$temp.'
-    }
-
-    while (compiler) {
-        if (compiler.hasKey(path)) {
-            break
-        } else {
-            compiler = compiler.parent
-            dist++
-        }
-    }
-    if (compiler) {
-        while (dist--) {
-            rel += '$parent.'
-        }
-        if (!compiler.bindings[path] && path.charAt(0) !== '$') {
-            compiler.createBinding(path)
-        }
-    } else {
-        self.createBinding(path)
-    }
-    return rel
-}
-
-/**
- *  Create a function from a string...
- *  this looks like evil magic but since all variables are limited
- *  to the VM's data it's actually properly sandboxed
- */
-function makeGetter (exp, raw) {
-    var fn
-    try {
-        fn = new Function(exp)
-    } catch (e) {
-        utils.warn('Error parsing expression: ' + raw)
-    }
-    return fn
-}
-
-/**
- *  Escape a leading dollar sign for regex construction
- */
-function escapeDollar (v) {
-    return v.charAt(0) === '$'
-        ? '\\' + v
-        : v
-}
-
-/**
- *  Parse and return an anonymous computed property getter function
- *  from an arbitrary expression, together with a list of paths to be
- *  created as bindings.
- */
-exports.parse = function (exp, compiler, data) {
-    // unicode and 'constructor' are not allowed for XSS security.
-    if (UNICODE_RE.test(exp) || CTOR_RE.test(exp)) {
-        utils.warn('Unsafe expression: ' + exp)
-        return
-    }
-    // extract variable names
-    var vars = getVariables(exp)
-    if (!vars.length) {
-        return makeGetter('return ' + exp, exp)
-    }
-    vars = utils.unique(vars)
-
-    var accessors = '',
-        has       = utils.hash(),
-        strings   = [],
-        // construct a regex to extract all valid variable paths
-        // ones that begin with "$" are particularly tricky
-        // because we can't use \b for them
-        pathRE = new RegExp(
-            "[^$\\w\\.](" +
-            vars.map(escapeDollar).join('|') +
-            ")[$\\w\\.]*\\b", 'g'
-        ),
-        body = (' ' + exp)
-            .replace(STR_SAVE_RE, saveStrings)
-            .replace(pathRE, replacePath)
-            .replace(STR_RESTORE_RE, restoreStrings)
-
-    body = accessors + 'return ' + body
-
-    function saveStrings (str) {
-        var i = strings.length
-        // escape newlines in strings so the expression
-        // can be correctly evaluated
-        strings[i] = str.replace(NEWLINE_RE, '\\n')
-        return '"' + i + '"'
-    }
-
-    function replacePath (path) {
-        // keep track of the first char
-        var c = path.charAt(0)
-        path = path.slice(1)
-        var val = 'this.' + traceScope(path, compiler, data) + path
-        if (!has[path]) {
-            accessors += val + ';'
-            has[path] = 1
-        }
-        // don't forget to put that first char back
-        return c + val
-    }
-
-    function restoreStrings (str, i) {
-        return strings[i]
-    }
-
-    return makeGetter(body, exp)
-}
-
-/**
- *  Evaluate an expression in the context of a compiler.
- *  Accepts additional data.
- */
-exports.eval = function (exp, compiler, data) {
-    var getter = exports.parse(exp, compiler, data), res
-    if (getter) {
-        // hack: temporarily attach the additional data so
-        // it can be accessed in the getter
-        compiler.vm.$temp = data
-        res = getter.call(compiler.vm)
-        delete compiler.vm.$temp
-    }
-    return res
-}
-});
-require.register("vue/src/template-parser.js", function(exports, require, module){
-var toFragment = require('./fragment');
-
-/**
- * Parses a template string or node and normalizes it into a
- * a node that can be used as a partial of a template option
- *
- * Possible values include
- * id selector: '#some-template-id'
- * template string: '<div><span>my template</span></div>'
- * DocumentFragment object
- * Node object of type Template
- */
-module.exports = function(template) {
-    var templateNode;
-
-    if (template instanceof window.DocumentFragment) {
-        // if the template is already a document fragment -- do nothing
-        return template
-    }
-
-    if (typeof template === 'string') {
-        // template by ID
-        if (template.charAt(0) === '#') {
-            templateNode = document.getElementById(template.slice(1))
-            if (!templateNode) return
-        } else {
-            return toFragment(template)
-        }
-    } else if (template.nodeType) {
-        templateNode = template
-    } else {
-        return
-    }
-
-    // if its a template tag and the browser supports it,
-    // its content is already a document fragment!
-    if (templateNode.tagName === 'TEMPLATE' && templateNode.content) {
-        return templateNode.content
-    }
-
-    if (templateNode.tagName === 'SCRIPT') {
-        return toFragment(templateNode.innerHTML)
-    }
-
-    return toFragment(templateNode.outerHTML);
-}
-
-});
-require.register("vue/src/text-parser.js", function(exports, require, module){
-var openChar        = '{',
-    endChar         = '}',
-    ESCAPE_RE       = /[-.*+?^${}()|[\]\/\\]/g,
-    // lazy require
-    Directive
-
-exports.Regex = buildInterpolationRegex()
-
-function buildInterpolationRegex () {
-    var open = escapeRegex(openChar),
-        end  = escapeRegex(endChar)
-    return new RegExp(open + open + open + '?(.+?)' + end + '?' + end + end)
-}
-
-function escapeRegex (str) {
-    return str.replace(ESCAPE_RE, '\\$&')
-}
-
-function setDelimiters (delimiters) {
-    openChar = delimiters[0]
-    endChar = delimiters[1]
-    exports.delimiters = delimiters
-    exports.Regex = buildInterpolationRegex()
-}
-
-/** 
- *  Parse a piece of text, return an array of tokens
- *  token types:
- *  1. plain string
- *  2. object with key = binding key
- *  3. object with key & html = true
- */
-function parse (text) {
-    if (!exports.Regex.test(text)) return null
-    var m, i, token, match, tokens = []
-    /* jshint boss: true */
-    while (m = text.match(exports.Regex)) {
-        i = m.index
-        if (i > 0) tokens.push(text.slice(0, i))
-        token = { key: m[1].trim() }
-        match = m[0]
-        token.html =
-            match.charAt(2) === openChar &&
-            match.charAt(match.length - 3) === endChar
-        tokens.push(token)
-        text = text.slice(i + m[0].length)
-    }
-    if (text.length) tokens.push(text)
-    return tokens
-}
-
-/**
- *  Parse an attribute value with possible interpolation tags
- *  return a Directive-friendly expression
- *
- *  e.g.  a {{b}} c  =>  "a " + b + " c"
- */
-function parseAttr (attr) {
-    Directive = Directive || require('./directive')
-    var tokens = parse(attr)
-    if (!tokens) return null
-    if (tokens.length === 1) return tokens[0].key
-    var res = [], token
-    for (var i = 0, l = tokens.length; i < l; i++) {
-        token = tokens[i]
-        res.push(
-            token.key
-                ? inlineFilters(token.key)
-                : ('"' + token + '"')
-        )
-    }
-    return res.join('+')
-}
-
-/**
- *  Inlines any possible filters in a binding
- *  so that we can combine everything into a huge expression
- */
-function inlineFilters (key) {
-    if (key.indexOf('|') > -1) {
-        var dirs = Directive.parse(key),
-            dir = dirs && dirs[0]
-        if (dir && dir.filters) {
-            key = Directive.inlineFilters(
-                dir.key,
-                dir.filters
-            )
-        }
-    }
-    return '(' + key + ')'
-}
-
-exports.parse         = parse
-exports.parseAttr     = parseAttr
-exports.setDelimiters = setDelimiters
-exports.delimiters    = [openChar, endChar]
-});
-require.register("vue/src/deps-parser.js", function(exports, require, module){
-var Emitter  = require('./emitter'),
-    utils    = require('./utils'),
-    Observer = require('./observer'),
-    catcher  = new Emitter()
-
-/**
- *  Auto-extract the dependencies of a computed property
- *  by recording the getters triggered when evaluating it.
- */
-function catchDeps (binding) {
-    if (binding.isFn) return
-    utils.log('\n- ' + binding.key)
-    var got = utils.hash()
-    binding.deps = []
-    catcher.on('get', function (dep) {
-        var has = got[dep.key]
-        if (
-            // avoid duplicate bindings
-            (has && has.compiler === dep.compiler) ||
-            // avoid repeated items as dependency
-            // only when the binding is from self or the parent chain
-            (dep.compiler.repeat && !isParentOf(dep.compiler, binding.compiler))
-        ) {
-            return
-        }
-        got[dep.key] = dep
-        utils.log('  - ' + dep.key)
-        binding.deps.push(dep)
-        dep.subs.push(binding)
-    })
-    binding.value.$get()
-    catcher.off('get')
-}
-
-/**
- *  Test if A is a parent of or equals B
- */
-function isParentOf (a, b) {
-    while (b) {
-        if (a === b) {
-            return true
-        }
-        b = b.parent
-    }
-}
-
-module.exports = {
-
-    /**
-     *  the observer that catches events triggered by getters
-     */
-    catcher: catcher,
-
-    /**
-     *  parse a list of computed property bindings
-     */
-    parse: function (bindings) {
-        utils.log('\nparsing dependencies...')
-        Observer.shouldGet = true
-        bindings.forEach(catchDeps)
-        Observer.shouldGet = false
-        utils.log('\ndone.')
-    }
-    
-}
-});
-require.register("vue/src/filters.js", function(exports, require, module){
-var utils    = require('./utils'),
-    get      = utils.get,
-    slice    = [].slice,
-    QUOTE_RE = /^'.*'$/,
-    filters  = module.exports = utils.hash()
-
-/**
- *  'abc' => 'Abc'
- */
-filters.capitalize = function (value) {
-    if (!value && value !== 0) return ''
-    value = value.toString()
-    return value.charAt(0).toUpperCase() + value.slice(1)
-}
-
-/**
- *  'abc' => 'ABC'
- */
-filters.uppercase = function (value) {
-    return (value || value === 0)
-        ? value.toString().toUpperCase()
-        : ''
-}
-
-/**
- *  'AbC' => 'abc'
- */
-filters.lowercase = function (value) {
-    return (value || value === 0)
-        ? value.toString().toLowerCase()
-        : ''
-}
-
-/**
- *  12345 => $12,345.00
- */
-filters.currency = function (value, sign) {
-    value = parseFloat(value)
-    if (!value && value !== 0) return ''
-    sign = sign || '$'
-    var s = Math.floor(value).toString(),
-        i = s.length % 3,
-        h = i > 0 ? (s.slice(0, i) + (s.length > 3 ? ',' : '')) : '',
-        f = '.' + value.toFixed(2).slice(-2)
-    return sign + h + s.slice(i).replace(/(\d{3})(?=\d)/g, '$1,') + f
-}
-
-/**
- *  args: 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']
- */
-filters.pluralize = function (value) {
-    var args = slice.call(arguments, 1)
-    return args.length > 1
-        ? (args[value - 1] || args[args.length - 1])
-        : (args[value - 1] || args[0] + 's')
-}
-
-/**
- *  A special filter that takes a handler function,
- *  wraps it so it only gets triggered on specific keypresses.
- *
- *  v-on only
- */
-
-var keyCodes = {
-    enter    : 13,
-    tab      : 9,
-    'delete' : 46,
-    up       : 38,
-    left     : 37,
-    right    : 39,
-    down     : 40,
-    esc      : 27
-}
-
-filters.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)
-        }
-    }
-}
-
-/**
- *  Filter filter for v-repeat
- */
-filters.filterBy = function (arr, searchKey, delimiter, dataKey) {
-
-    // allow optional `in` delimiter
-    // because why not
-    if (delimiter && delimiter !== 'in') {
-        dataKey = delimiter
-    }
-
-    // get the search string
-    var search = stripQuotes(searchKey) || this.$get(searchKey)
-    if (!search) return arr
-    search = search.toLowerCase()
-
-    // get the optional dataKey
-    dataKey = dataKey && (stripQuotes(dataKey) || this.$get(dataKey))
-
-    // convert object to array
-    if (!Array.isArray(arr)) {
-        arr = utils.objectToArray(arr)
-    }
-
-    return arr.filter(function (item) {
-        return dataKey
-            ? contains(get(item, dataKey), search)
-            : contains(item, search)
-    })
-
-}
-
-filters.filterBy.computed = true
-
-/**
- *  Sort fitler for v-repeat
- */
-filters.orderBy = function (arr, sortKey, reverseKey) {
-
-    var key = stripQuotes(sortKey) || this.$get(sortKey)
-    if (!key) return arr
-
-    // convert object to array
-    if (!Array.isArray(arr)) {
-        arr = utils.objectToArray(arr)
-    }
-
-    var order = 1
-    if (reverseKey) {
-        if (reverseKey === '-1') {
-            order = -1
-        } else if (reverseKey.charAt(0) === '!') {
-            reverseKey = reverseKey.slice(1)
-            order = this.$get(reverseKey) ? 1 : -1
-        } else {
-            order = this.$get(reverseKey) ? -1 : 1
-        }
-    }
-
-    // sort on a copy to avoid mutating original array
-    return arr.slice().sort(function (a, b) {
-        a = get(a, key)
-        b = get(b, key)
-        return a === b ? 0 : a > b ? order : -order
-    })
-
-}
-
-filters.orderBy.computed = true
-
-// Array filter helpers -------------------------------------------------------
-
-/**
- *  String contain helper
- */
-function contains (val, search) {
-    /* jshint eqeqeq: false */
-    if (utils.isObject(val)) {
-        for (var key in val) {
-            if (contains(val[key], search)) {
-                return true
-            }
-        }
-    } else if (val != null) {
-        return val.toString().toLowerCase().indexOf(search) > -1
-    }
-}
-
-/**
- *  Test whether a string is in quotes,
- *  if yes return stripped string
- */
-function stripQuotes (str) {
-    if (QUOTE_RE.test(str)) {
-        return str.slice(1, -1)
-    }
-}
-});
-require.register("vue/src/transition.js", function(exports, require, module){
-var endEvents  = sniffEndEvents(),
-    config     = require('./config'),
-    // batch enter animations so we only force the layout once
-    Batcher    = require('./batcher'),
-    batcher    = new Batcher(),
-    // cache timer functions
-    setTO      = window.setTimeout,
-    clearTO    = window.clearTimeout,
-    // exit codes for testing
-    codes = {
-        CSS_E     : 1,
-        CSS_L     : 2,
-        JS_E      : 3,
-        JS_L      : 4,
-        CSS_SKIP  : -1,
-        JS_SKIP   : -2,
-        JS_SKIP_E : -3,
-        JS_SKIP_L : -4,
-        INIT      : -5,
-        SKIP      : -6
-    }
-
-// force layout before triggering transitions/animations
-batcher._preFlush = function () {
-    /* jshint unused: false */
-    var f = document.body.offsetHeight
-}
-
-/**
- *  stage:
- *    1 = enter
- *    2 = leave
- */
-var transition = module.exports = function (el, stage, cb, compiler) {
-
-    var changeState = function () {
-        cb()
-        compiler.execHook(stage > 0 ? 'attached' : 'detached')
-    }
-
-    if (compiler.init) {
-        changeState()
-        return codes.INIT
-    }
-
-    var hasTransition = el.vue_trans === '',
-        hasAnimation  = el.vue_anim === '',
-        effectId      = el.vue_effect
-
-    if (effectId) {
-        return applyTransitionFunctions(
-            el,
-            stage,
-            changeState,
-            effectId,
-            compiler
-        )
-    } else if (hasTransition || hasAnimation) {
-        return applyTransitionClass(
-            el,
-            stage,
-            changeState,
-            hasAnimation
-        )
-    } else {
-        changeState()
-        return codes.SKIP
-    }
-
-}
-
-/**
- *  Togggle a CSS class to trigger transition
- */
-function applyTransitionClass (el, stage, changeState, hasAnimation) {
-
-    if (!endEvents.trans) {
-        changeState()
-        return codes.CSS_SKIP
-    }
-
-    // if the browser supports transition,
-    // it must have classList...
-    var onEnd,
-        classList        = el.classList,
-        existingCallback = el.vue_trans_cb,
-        enterClass       = config.enterClass,
-        leaveClass       = config.leaveClass,
-        endEvent         = hasAnimation ? endEvents.anim : endEvents.trans
-
-    // cancel unfinished callbacks and jobs
-    if (existingCallback) {
-        el.removeEventListener(endEvent, existingCallback)
-        classList.remove(enterClass)
-        classList.remove(leaveClass)
-        el.vue_trans_cb = null
-    }
-
-    if (stage > 0) { // enter
-
-        // set to enter state before appending
-        classList.add(enterClass)
-        // append
-        changeState()
-        // trigger transition
-        if (!hasAnimation) {
-            batcher.push({
-                execute: function () {
-                    classList.remove(enterClass)
-                }
-            })
-        } else {
-            onEnd = function (e) {
-                if (e.target === el) {
-                    el.removeEventListener(endEvent, onEnd)
-                    el.vue_trans_cb = null
-                    classList.remove(enterClass)
-                }
-            }
-            el.addEventListener(endEvent, onEnd)
-            el.vue_trans_cb = onEnd
-        }
-        return codes.CSS_E
-
-    } else { // leave
-
-        if (el.offsetWidth || el.offsetHeight) {
-            // trigger hide transition
-            classList.add(leaveClass)
-            onEnd = function (e) {
-                if (e.target === el) {
-                    el.removeEventListener(endEvent, onEnd)
-                    el.vue_trans_cb = null
-                    // actually remove node here
-                    changeState()
-                    classList.remove(leaveClass)
-                }
-            }
-            // attach transition end listener
-            el.addEventListener(endEvent, onEnd)
-            el.vue_trans_cb = onEnd
-        } else {
-            // directly remove invisible elements
-            changeState()
-        }
-        return codes.CSS_L
-        
-    }
-
-}
-
-function applyTransitionFunctions (el, stage, changeState, effectId, compiler) {
-
-    var funcs = compiler.getOption('effects', effectId)
-    if (!funcs) {
-        changeState()
-        return codes.JS_SKIP
-    }
-
-    var enter = funcs.enter,
-        leave = funcs.leave,
-        timeouts = el.vue_timeouts
-
-    // clear previous timeouts
-    if (timeouts) {
-        var i = timeouts.length
-        while (i--) {
-            clearTO(timeouts[i])
-        }
-    }
-
-    timeouts = el.vue_timeouts = []
-    function timeout (cb, delay) {
-        var id = setTO(function () {
-            cb()
-            timeouts.splice(timeouts.indexOf(id), 1)
-            if (!timeouts.length) {
-                el.vue_timeouts = null
-            }
-        }, delay)
-        timeouts.push(id)
-    }
-
-    if (stage > 0) { // enter
-        if (typeof enter !== 'function') {
-            changeState()
-            return codes.JS_SKIP_E
-        }
-        enter(el, changeState, timeout)
-        return codes.JS_E
-    } else { // leave
-        if (typeof leave !== 'function') {
-            changeState()
-            return codes.JS_SKIP_L
-        }
-        leave(el, changeState, timeout)
-        return codes.JS_L
-    }
-
-}
-
-/**
- *  Sniff proper transition end event name
- */
-function sniffEndEvents () {
-    var el = document.createElement('vue'),
-        defaultEvent = 'transitionend',
-        events = {
-            'webkitTransition' : 'webkitTransitionEnd',
-            'transition'       : defaultEvent,
-            'mozTransition'    : defaultEvent
-        },
-        ret = {}
-    for (var name in events) {
-        if (el.style[name] !== undefined) {
-            ret.trans = events[name]
-            break
-        }
-    }
-    ret.anim = el.style.animation === ''
-        ? 'animationend'
-        : 'webkitAnimationEnd'
-    return ret
-}
-
-// Expose some stuff for testing purposes
-transition.codes = codes
-transition.sniff = sniffEndEvents
-});
-require.register("vue/src/batcher.js", function(exports, require, module){
-var utils = require('./utils')
-
-function Batcher () {
-    this.reset()
-}
-
-var BatcherProto = Batcher.prototype
-
-BatcherProto.push = function (job) {
-    if (!job.id || !this.has[job.id]) {
-        this.queue.push(job)
-        this.has[job.id] = job
-        if (!this.waiting) {
-            this.waiting = true
-            utils.nextTick(utils.bind(this.flush, this))
-        }
-    } else if (job.override) {
-        var oldJob = this.has[job.id]
-        oldJob.cancelled = true
-        this.queue.push(job)
-        this.has[job.id] = job
-    }
-}
-
-BatcherProto.flush = function () {
-    // before flush hook
-    if (this._preFlush) this._preFlush()
-    // do not cache length because more jobs might be pushed
-    // as we execute existing jobs
-    for (var i = 0; i < this.queue.length; i++) {
-        var job = this.queue[i]
-        if (!job.cancelled) {
-            job.execute()
-        }
-    }
-    this.reset()
-}
-
-BatcherProto.reset = function () {
-    this.has = utils.hash()
-    this.queue = []
-    this.waiting = false
-}
-
-module.exports = Batcher
-});
-require.register("vue/src/directives/index.js", function(exports, require, module){
-var utils      = require('../utils'),
-    config     = require('../config'),
-    transition = require('../transition'),
-    directives = module.exports = utils.hash()
-
-/**
- *  Nest and manage a Child VM
- */
-directives.component = {
-    isLiteral: true,
-    bind: function () {
-        if (!this.el.vue_vm) {
-            this.childVM = new this.Ctor({
-                el: this.el,
-                parent: this.vm
-            })
-        }
-    },
-    unbind: function () {
-        if (this.childVM) {
-            this.childVM.$destroy()
-        }
-    }
-}
-
-/**
- *  Binding HTML attributes
- */
-directives.attr = {
-    bind: function () {
-        var params = this.vm.$options.paramAttributes
-        this.isParam = params && params.indexOf(this.arg) > -1
-    },
-    update: function (value) {
-        if (value || value === 0) {
-            this.el.setAttribute(this.arg, value)
-        } else {
-            this.el.removeAttribute(this.arg)
-        }
-        if (this.isParam) {
-            this.vm[this.arg] = utils.checkNumber(value)
-        }
-    }
-}
-
-/**
- *  Binding textContent
- */
-directives.text = {
-    bind: function () {
-        this.attr = this.el.nodeType === 3
-            ? 'nodeValue'
-            : 'textContent'
-    },
-    update: function (value) {
-        this.el[this.attr] = utils.guard(value)
-    }
-}
-
-/**
- *  Binding CSS display property
- */
-directives.show = function (value) {
-    var el = this.el,
-        target = value ? '' : 'none',
-        change = function () {
-            el.style.display = target
-        }
-    transition(el, value ? 1 : -1, change, this.compiler)
-}
-
-/**
- *  Binding CSS classes
- */
-directives['class'] = function (value) {
-    if (this.arg) {
-        utils[value ? 'addClass' : 'removeClass'](this.el, this.arg)
-    } else {
-        if (this.lastVal) {
-            utils.removeClass(this.el, this.lastVal)
-        }
-        if (value) {
-            utils.addClass(this.el, value)
-            this.lastVal = value
-        }
-    }
-}
-
-/**
- *  Only removed after the owner VM is ready
- */
-directives.cloak = {
-    isEmpty: true,
-    bind: function () {
-        var el = this.el
-        this.compiler.observer.once('hook:ready', function () {
-            el.removeAttribute(config.prefix + '-cloak')
-        })
-    }
-}
-
-/**
- *  Store a reference to self in parent VM's $
- */
-directives.ref = {
-    isLiteral: true,
-    bind: function () {
-        var id = this.expression
-        if (id) {
-            this.vm.$parent.$[id] = this.vm
-        }
-    },
-    unbind: function () {
-        var id = this.expression
-        if (id) {
-            delete this.vm.$parent.$[id]
-        }
-    }
-}
-
-directives.on      = require('./on')
-directives.repeat  = require('./repeat')
-directives.model   = require('./model')
-directives['if']   = require('./if')
-directives['with'] = require('./with')
-directives.html    = require('./html')
-directives.style   = require('./style')
-directives.partial = require('./partial')
-directives.view    = require('./view')
-});
-require.register("vue/src/directives/if.js", function(exports, require, module){
-var utils    = require('../utils')
-
-/**
- *  Manages a conditional child VM
- */
-module.exports = {
-
-    bind: function () {
-        
-        this.parent = this.el.parentNode
-        this.ref    = document.createComment('vue-if')
-        this.Ctor   = this.compiler.resolveComponent(this.el)
-
-        // insert ref
-        this.parent.insertBefore(this.ref, this.el)
-        this.parent.removeChild(this.el)
-
-        if (utils.attr(this.el, 'view')) {
-            utils.warn(
-                'Conflict: v-if cannot be used together with v-view. ' +
-                'Just set v-view\'s binding value to empty string to empty it.'
-            )
-        }
-        if (utils.attr(this.el, 'repeat')) {
-            utils.warn(
-                'Conflict: v-if cannot be used together with v-repeat. ' +
-                'Use `v-show` or the `filterBy` filter instead.'
-            )
-        }
-    },
-
-    update: function (value) {
-
-        if (!value) {
-            this.unbind()
-        } else if (!this.childVM) {
-            this.childVM = new this.Ctor({
-                el: this.el.cloneNode(true),
-                parent: this.vm
-            })
-            if (this.compiler.init) {
-                this.parent.insertBefore(this.childVM.$el, this.ref)
-            } else {
-                this.childVM.$before(this.ref)
-            }
-        }
-        
-    },
-
-    unbind: function () {
-        if (this.childVM) {
-            this.childVM.$destroy()
-            this.childVM = null
-        }
-    }
-}
-});
-require.register("vue/src/directives/repeat.js", function(exports, require, module){
-var utils      = require('../utils'),
-    config     = require('../config')
-
-/**
- *  Binding that manages VMs based on an Array
- */
-module.exports = {
-
-    bind: function () {
-
-        this.identifier = '$r' + this.id
-
-        // a hash to cache the same expressions on repeated instances
-        // so they don't have to be compiled for every single instance
-        this.expCache = utils.hash()
-
-        var el   = this.el,
-            ctn  = this.container = el.parentNode
-
-        // extract child Id, if any
-        this.childId = this.compiler.eval(utils.attr(el, 'ref'))
-
-        // create a comment node as a reference node for DOM insertions
-        this.ref = document.createComment(config.prefix + '-repeat-' + this.key)
-        ctn.insertBefore(this.ref, el)
-        ctn.removeChild(el)
-
-        this.collection = null
-        this.vms = null
-
-    },
-
-    update: function (collection) {
-
-        if (!Array.isArray(collection)) {
-            if (utils.isObject(collection)) {
-                collection = utils.objectToArray(collection)
-            } else {
-                utils.warn('v-repeat only accepts Array or Object values.')
-            }
-        }
-
-        // keep reference of old data and VMs
-        // so we can reuse them if possible
-        this.oldVMs = this.vms
-        this.oldCollection = this.collection
-        collection = this.collection = collection || []
-
-        var isObject = collection[0] && utils.isObject(collection[0])
-        this.vms = this.oldCollection
-            ? this.diff(collection, isObject)
-            : this.init(collection, isObject)
-
-        if (this.childId) {
-            this.vm.$[this.childId] = this.vms
-        }
-
-    },
-
-    init: function (collection, isObject) {
-        var vm, vms = []
-        for (var i = 0, l = collection.length; i < l; i++) {
-            vm = this.build(collection[i], i, isObject)
-            vms.push(vm)
-            if (this.compiler.init) {
-                this.container.insertBefore(vm.$el, this.ref)
-            } else {
-                vm.$before(this.ref)
-            }
-        }
-        return vms
-    },
-
-    /**
-     *  Diff the new array with the old
-     *  and determine the minimum amount of DOM manipulations.
-     */
-    diff: function (newCollection, isObject) {
-
-        var i, l, item, vm,
-            oldIndex,
-            targetNext,
-            currentNext,
-            nextEl,
-            ctn    = this.container,
-            oldVMs = this.oldVMs,
-            vms    = []
-
-        vms.length = newCollection.length
-
-        // first pass, collect new reused and new created
-        for (i = 0, l = newCollection.length; i < l; i++) {
-            item = newCollection[i]
-            if (isObject) {
-                item.$index = i
-                if (item.__emitter__ && item.__emitter__[this.identifier]) {
-                    // this piece of data is being reused.
-                    // record its final position in reused vms
-                    item.$reused = true
-                } else {
-                    vms[i] = this.build(item, i, isObject)
-                }
-            } else {
-                // we can't attach an identifier to primitive values
-                // so have to do an indexOf...
-                oldIndex = indexOf(oldVMs, item)
-                if (oldIndex > -1) {
-                    // record the position on the existing vm
-                    oldVMs[oldIndex].$reused = true
-                    oldVMs[oldIndex].$data.$index = i
-                } else {
-                    vms[i] = this.build(item, i, isObject)
-                }
-            }
-        }
-
-        // second pass, collect old reused and destroy unused
-        for (i = 0, l = oldVMs.length; i < l; i++) {
-            vm = oldVMs[i]
-            item = this.arg
-                ? vm.$data[this.arg]
-                : vm.$data
-            if (item.$reused) {
-                vm.$reused = true
-                delete item.$reused
-            }
-            if (vm.$reused) {
-                // update the index to latest
-                vm.$index = item.$index
-                // the item could have had a new key
-                if (item.$key && item.$key !== vm.$key) {
-                    vm.$key = item.$key
-                }
-                vms[vm.$index] = vm
-            } else {
-                // this one can be destroyed.
-                if (item.__emitter__) {
-                    delete item.__emitter__[this.identifier]
-                }
-                vm.$destroy()
-            }
-        }
-
-        // final pass, move/insert DOM elements
-        i = vms.length
-        while (i--) {
-            vm = vms[i]
-            item = vm.$data
-            targetNext = vms[i + 1]
-            if (vm.$reused) {
-                nextEl = vm.$el.nextSibling
-                // destroyed VMs' element might still be in the DOM
-                // due to transitions
-                while (!nextEl.vue_vm && nextEl !== this.ref) {
-                    nextEl = nextEl.nextSibling
-                }
-                currentNext = nextEl.vue_vm
-                if (currentNext !== targetNext) {
-                    if (!targetNext) {
-                        ctn.insertBefore(vm.$el, this.ref)
-                    } else {
-                        nextEl = targetNext.$el
-                        // new VMs' element might not be in the DOM yet
-                        // due to transitions
-                        while (!nextEl.parentNode) {
-                            targetNext = vms[nextEl.vue_vm.$index + 1]
-                            nextEl = targetNext
-                                ? targetNext.$el
-                                : this.ref
-                        }
-                        ctn.insertBefore(vm.$el, nextEl)
-                    }
-                }
-                delete vm.$reused
-                delete item.$index
-                delete item.$key
-            } else { // a new vm
-                vm.$before(targetNext ? targetNext.$el : this.ref)
-            }
-        }
-
-        return vms
-    },
-
-    build: function (data, index, isObject) {
-
-        // wrap non-object values
-        var raw, alias,
-            wrap = !isObject || this.arg
-        if (wrap) {
-            raw = data
-            alias = this.arg || '$value'
-            data = {}
-            data[alias] = raw
-        }
-        data.$index = index
-
-        var el = this.el.cloneNode(true),
-            Ctor = this.compiler.resolveComponent(el, data),
-            vm = new Ctor({
-                el: el,
-                data: data,
-                parent: this.vm,
-                compilerOptions: {
-                    repeat: true,
-                    expCache: this.expCache
-                }
-            })
-
-        if (isObject) {
-            // attach an ienumerable identifier to the raw data
-            (raw || data).__emitter__[this.identifier] = true
-        }
-
-        return vm
-
-    },
-
-    unbind: function () {
-        if (this.childId) {
-            delete this.vm.$[this.childId]
-        }
-        if (this.vms) {
-            var i = this.vms.length
-            while (i--) {
-                this.vms[i].$destroy()
-            }
-        }
-    }
-}
-
-// Helpers --------------------------------------------------------------------
-
-/**
- *  Find an object or a wrapped data object
- *  from an Array
- */
-function indexOf (vms, obj) {
-    for (var vm, i = 0, l = vms.length; i < l; i++) {
-        vm = vms[i]
-        if (!vm.$reused && vm.$value === obj) {
-            return i
-        }
-    }
-    return -1
-}
-});
-require.register("vue/src/directives/on.js", function(exports, require, module){
-var utils    = require('../utils')
-
-/**
- *  Binding for event listeners
- */
-module.exports = {
-
-    isFn: true,
-
-    bind: function () {
-        this.context = this.binding.isExp
-            ? this.vm
-            : this.binding.compiler.vm
-        if (this.el.tagName === 'IFRAME' && this.arg !== 'load') {
-            var self = this
-            this.iframeBind = function () {
-                self.el.contentWindow.addEventListener(self.arg, self.handler)
-            }
-            this.el.addEventListener('load', this.iframeBind)
-        }
-    },
-
-    update: function (handler) {
-        if (typeof handler !== 'function') {
-            utils.warn('Directive "v-on:' + this.expression + '" expects a method.')
-            return
-        }
-        this.reset()
-        var vm = this.vm,
-            context = this.context
-        this.handler = function (e) {
-            e.targetVM = vm
-            context.$event = e
-            var res = handler.call(context, e)
-            context.$event = null
-            return res
-        }
-        if (this.iframeBind) {
-            this.iframeBind()
-        } else {
-            this.el.addEventListener(this.arg, this.handler)
-        }
-    },
-
-    reset: function () {
-        var el = this.iframeBind
-            ? this.el.contentWindow
-            : this.el
-        if (this.handler) {
-            el.removeEventListener(this.arg, this.handler)
-        }
-    },
-
-    unbind: function () {
-        this.reset()
-        this.el.removeEventListener('load', this.iframeBind)
-    }
-}
-});
-require.register("vue/src/directives/model.js", function(exports, require, module){
-var utils = require('../utils'),
-    isIE9 = navigator.userAgent.indexOf('MSIE 9.0') > 0,
-    filter = [].filter
-
-/**
- *  Returns an array of values from a multiple select
- */
-function getMultipleSelectOptions (select) {
-    return filter
-        .call(select.options, function (option) {
-            return option.selected
-        })
-        .map(function (option) {
-            return option.value || option.text
-        })
-}
-
-/**
- *  Two-way binding for form input elements
- */
-module.exports = {
-
-    bind: function () {
-
-        var self = this,
-            el   = self.el,
-            type = el.type,
-            tag  = el.tagName
-
-        self.lock = false
-        self.ownerVM = self.binding.compiler.vm
-
-        // determine what event to listen to
-        self.event =
-            (self.compiler.options.lazy ||
-            tag === 'SELECT' ||
-            type === 'checkbox' || type === 'radio')
-                ? 'change'
-                : 'input'
-
-        // determine the attribute to change when updating
-        self.attr = type === 'checkbox'
-            ? 'checked'
-            : (tag === 'INPUT' || tag === 'SELECT' || tag === 'TEXTAREA')
-                ? 'value'
-                : 'innerHTML'
-
-        // select[multiple] support
-        if(tag === 'SELECT' && el.hasAttribute('multiple')) {
-            this.multi = true
-        }
-
-        var compositionLock = false
-        self.cLock = function () {
-            compositionLock = true
-        }
-        self.cUnlock = function () {
-            compositionLock = false
-        }
-        el.addEventListener('compositionstart', this.cLock)
-        el.addEventListener('compositionend', this.cUnlock)
-
-        // attach listener
-        self.set = self.filters
-            ? function () {
-                if (compositionLock) return
-                // if this directive has filters
-                // we need to let the vm.$set trigger
-                // update() so filters are applied.
-                // therefore we have to record cursor position
-                // so that after vm.$set changes the input
-                // value we can put the cursor back at where it is
-                var cursorPos
-                try { cursorPos = el.selectionStart } catch (e) {}
-
-                self._set()
-
-                // since updates are async
-                // we need to reset cursor position async too
-                utils.nextTick(function () {
-                    if (cursorPos !== undefined) {
-                        el.setSelectionRange(cursorPos, cursorPos)
-                    }
-                })
-            }
-            : function () {
-                if (compositionLock) return
-                // no filters, don't let it trigger update()
-                self.lock = true
-
-                self._set()
-
-                utils.nextTick(function () {
-                    self.lock = false
-                })
-            }
-        el.addEventListener(self.event, self.set)
-
-        // fix shit for IE9
-        // since it doesn't fire input on backspace / del / cut
-        if (isIE9) {
-            self.onCut = function () {
-                // cut event fires before the value actually changes
-                utils.nextTick(function () {
-                    self.set()
-                })
-            }
-            self.onDel = function (e) {
-                if (e.keyCode === 46 || e.keyCode === 8) {
-                    self.set()
-                }
-            }
-            el.addEventListener('cut', self.onCut)
-            el.addEventListener('keyup', self.onDel)
-        }
-    },
-
-    _set: function () {
-        this.ownerVM.$set(
-            this.key, this.multi
-                ? getMultipleSelectOptions(this.el)
-                : this.el[this.attr]
-        )
-    },
-
-    update: function (value, init) {
-        /* jshint eqeqeq: false */
-        // sync back inline value if initial data is undefined
-        if (init && value === undefined) {
-            return this._set()
-        }
-        if (this.lock) return
-        var el = this.el
-        if (el.tagName === 'SELECT') { // select dropdown
-            el.selectedIndex = -1
-            if(this.multi && Array.isArray(value)) {
-                value.forEach(this.updateSelect, this)
-            } else {
-                this.updateSelect(value)
-            }
-        } else if (el.type === 'radio') { // radio button
-            el.checked = value == el.value
-        } else if (el.type === 'checkbox') { // checkbox
-            el.checked = !!value
-        } else {
-            el[this.attr] = utils.guard(value)
-        }
-    },
-
-    updateSelect: function (value) {
-        /* jshint eqeqeq: false */
-        // setting <select>'s value in IE9 doesn't work
-        // we have to manually loop through the options
-        var options = this.el.options,
-            i = options.length
-        while (i--) {
-            if (options[i].value == value) {
-                options[i].selected = true
-                break
-            }
-        }
-    },
-
-    unbind: function () {
-        var el = this.el
-        el.removeEventListener(this.event, this.set)
-        el.removeEventListener('compositionstart', this.cLock)
-        el.removeEventListener('compositionend', this.cUnlock)
-        if (isIE9) {
-            el.removeEventListener('cut', this.onCut)
-            el.removeEventListener('keyup', this.onDel)
-        }
-    }
-}
-});
-require.register("vue/src/directives/with.js", function(exports, require, module){
-var utils = require('../utils')
-
-/**
- *  Binding for inheriting data from parent VMs.
- */
-module.exports = {
-
-    bind: function () {
-
-        var self      = this,
-            childKey  = self.arg,
-            parentKey = self.key,
-            compiler  = self.compiler,
-            owner     = self.binding.compiler
-
-        if (compiler === owner) {
-            this.alone = true
-            return
-        }
-
-        if (childKey) {
-            if (!compiler.bindings[childKey]) {
-                compiler.createBinding(childKey)
-            }
-            // sync changes on child back to parent
-            compiler.observer.on('change:' + childKey, function (val) {
-                if (compiler.init) return
-                if (!self.lock) {
-                    self.lock = true
-                    utils.nextTick(function () {
-                        self.lock = false
-                    })
-                }
-                owner.vm.$set(parentKey, val)
-            })
-        }
-    },
-
-    update: function (value) {
-        // sync from parent
-        if (!this.alone && !this.lock) {
-            if (this.arg) {
-                this.vm.$set(this.arg, value)
-            } else if (this.vm.$data !== value) {
-                this.vm.$data = value
-            }
-        }
-    }
-
-}
-});
-require.register("vue/src/directives/html.js", function(exports, require, module){
-var utils = require('../utils'),
-    slice = [].slice
-
-/**
- *  Binding for innerHTML
- */
-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 = []
-        }
-    },
-
-    update: function (value) {
-        value = utils.guard(value)
-        if (this.nodes) {
-            this.swap(value)
-        } else {
-            this.el.innerHTML = value
-        }
-    },
-
-    swap: function (value) {
-        var parent = this.el.parentNode,
-            nodes  = this.nodes,
-            i      = nodes.length
-        // remove old nodes
-        while (i--) {
-            parent.removeChild(nodes[i])
-        }
-        // convert new value to a fragment
-        var frag = utils.toFragment(value)
-        // save a reference to these nodes so we can remove later
-        this.nodes = slice.call(frag.childNodes)
-        parent.insertBefore(frag, this.el)
-    }
-}
-});
-require.register("vue/src/directives/style.js", function(exports, require, module){
-var prefixes = ['-webkit-', '-moz-', '-ms-']
-
-/**
- *  Binding for CSS styles
- */
-module.exports = {
-
-    bind: function () {
-        var prop = this.arg
-        if (!prop) return
-        if (prop.charAt(0) === '$') {
-            // properties that start with $ will be auto-prefixed
-            prop = prop.slice(1)
-            this.prefixed = true
-        }
-        this.prop = prop
-    },
-
-    update: function (value) {
-        var prop = this.prop,
-            isImportant
-        /* jshint eqeqeq: true */
-        // cast possible numbers/booleans into strings
-        if (value != null) value += ''
-        if (prop) {
-            if (value) {
-                isImportant = value.slice(-10) === '!important'
-                    ? 'important'
-                    : ''
-                if (isImportant) {
-                    value = value.slice(0, -10).trim()
-                }
-            }
-            this.el.style.setProperty(prop, value, isImportant)
-            if (this.prefixed) {
-                var i = prefixes.length
-                while (i--) {
-                    this.el.style.setProperty(prefixes[i] + prop, value, isImportant)
-                }
-            }
-        } else {
-            this.el.style.cssText = value
-        }
-    }
-
-}
-});
-require.register("vue/src/directives/partial.js", function(exports, require, module){
-var utils = require('../utils')
-
-/**
- *  Binding for partials
- */
-module.exports = {
-
-    isLiteral: true,
-
-    bind: function () {
-
-        var id = this.expression
-        if (!id) return
-
-        var el       = this.el,
-            compiler = this.compiler,
-            partial  = compiler.getOption('partials', id)
-
-        if (!partial) {
-            if (id === 'yield') {
-                utils.warn('{{>yield}} syntax has been deprecated. Use <content> tag instead.')
-            }
-            return
-        }
-
-        partial = partial.cloneNode(true)
-
-        // comment ref node means inline partial
-        if (el.nodeType === 8) {
-
-            // keep a ref for the partial's content nodes
-            var nodes = [].slice.call(partial.childNodes),
-                parent = el.parentNode
-            parent.insertBefore(partial, el)
-            parent.removeChild(el)
-            // compile partial after appending, because its children's parentNode
-            // will change from the fragment to the correct parentNode.
-            // This could affect directives that need access to its element's parentNode.
-            nodes.forEach(compiler.compile, compiler)
-
-        } else {
-
-            // just set innerHTML...
-            el.innerHTML = ''
-            el.appendChild(partial)
-
-        }
-    }
-
-}
-});
-require.register("vue/src/directives/view.js", function(exports, require, module){
-/**
- *  Manages a conditional child VM using the
- *  binding's value as the component ID.
- */
-module.exports = {
-
-    bind: function () {
-
-        // track position in DOM with a ref node
-        var el       = this.raw = this.el,
-            parent   = el.parentNode,
-            ref      = this.ref = document.createComment('v-view')
-        parent.insertBefore(ref, el)
-        parent.removeChild(el)
-
-        // cache original content
-        /* jshint boss: true */
-        var node,
-            frag = this.inner = document.createElement('div')
-        while (node = el.firstChild) {
-            frag.appendChild(node)
-        }
-
-    },
-
-    update: function(value) {
-
-        this.unbind()
-
-        var Ctor  = this.compiler.getOption('components', value)
-        if (!Ctor) return
-
-        this.childVM = new Ctor({
-            el: this.raw.cloneNode(true),
-            parent: this.vm,
-            compilerOptions: {
-                rawContent: this.inner.cloneNode(true)
-            }
-        })
-
-        this.el = this.childVM.$el
-        if (this.compiler.init) {
-            this.ref.parentNode.insertBefore(this.el, this.ref)
-        } else {
-            this.childVM.$before(this.ref)
-        }
-
-    },
-
-    unbind: function() {
-        if (this.childVM) {
-            this.childVM.$destroy()
-        }
-    }
-
-}
-});
-require.alias("vue/src/main.js", "vue/index.js");
-if (typeof exports == 'object') {
-  module.exports = require('vue');
-} else if (typeof define == 'function' && define.amd) {
-  define(function(){ return require('vue'); });
-} else {
-  window['Vue'] = require('vue');
-}})();
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/dist/vue.min.js b/vendor/assets/javascripts/bower/vue/dist/vue.min.js
index 6d777a5..b0e7054 100644
--- a/vendor/assets/javascripts/bower/vue/dist/vue.min.js
+++ b/vendor/assets/javascripts/bower/vue/dist/vue.min.js
@@ -1,7 +1,7 @@
-/*
- Vue.js v0.10.6
- (c) 2014 Evan You
- License: MIT
-*/
-!function(){"use strict";function e(t,i,r){var n=e.resolve(t);if(null!=n){var s=e.modules[n];if(!s._resolving&&!s.exports){var o={};o.exports={},o.client=o.component=!0,s._resolving=!0,s.call(this,o.exports,e.relative(n),o),delete s._resolving,s.exports=o.exports}return s.exports}}e.modules={},e.aliases={},e.exts=["",".js",".json","/index.js","/index.json"],e.resolve=function(t){"/"===t.charAt(0)&&(t=t.slice(1));for(var i=0;5>i;i++){var r=t+e.exts[i];if(e.modules.hasOwnProperty(r))return r;if(e.aliases.hasOwnProperty(r))return e.aliases[r]}},e.normalize=function(e,t){var i=[];if("."!=t.charAt(0))return t;e=e.split("/"),t=t.split("/");for(var r=0;r<t.length;++r)".."===t[r]?e.pop():"."!=t[r]&&""!=t[r]&&i.push(t[r]);return e.concat(i).join("/")},e.register=function(t,i){e.modules[t]=i},e.alias=function(t,i){e.modules.hasOwnProperty(t)&&(e.aliases[i]=t)},e.relative=function(t){function i(r){var n=i.resolve(r);return e(n,t,r)}var r=e.normalize(t,"..");return i.resolve=function(i){var n=i.charAt(0);if("/"===n)return i.slice(1);if("."===n)return e.normalize(r,i);for(var s=t.split("/"),o=s.length;o--&&"deps"!==s[o];);return i=s.slice(0,o+2).join("/")+"/deps/"+i},i.exists=function(t){return e.modules.hasOwnProperty(i.resolve(t))},i},e.register("vue/src/main.js",function(e,t,i){function r(e){var t=this;e.data&&(e.defaultData=e.data,delete e.data),t!==o&&(e=n(e,t.options,!0)),a.processOptions(e);var i=function(i,r){r||(i=n(i,e,!0)),t.call(this,i,!0)},s=i.prototype=Object.create(t.prototype);return a.defProtected(s,"constructor",i),i.extend=r,i.super=t,i.options=e,l.forEach(function(e){i[e]=o[e]}),i.use=o.use,i.require=o.require,i}function n(e,t,i){if(e=e||{},!t)return e;for(var r in t)if("el"!==r){var s=e[r],c=t[r];i&&"function"==typeof s&&c?(e[r]=[s],Array.isArray(c)?e[r]=e[r].concat(c):e[r].push(c)):!i||!a.isTrueObject(s)&&!a.isTrueObject(c)||c instanceof o?void 0===s&&(e[r]=c):e[r]=n(s,c)}return e}var s=t("./config"),o=t("./viewmodel"),a=t("./utils"),c=a.hash,l=["directive","filter","partial","effect","component"],u={utils:a,config:s,transition:t("./transition"),observer:t("./observer")};o.options=s.globalAssets={directives:t("./directives"),filters:t("./filters"),partials:c(),effects:c(),components:c()},l.forEach(function(e){o[e]=function(t,i){var r=this.options[e+"s"];return r||(r=this.options[e+"s"]=c()),i?("partial"===e?i=a.parseTemplateOption(i):"component"===e?i=a.toConstructor(i):"filter"===e&&a.checkFilter(i),r[t]=i,this):r[t]}}),o.config=function(e,t){if("string"==typeof e){if(void 0===t)return s[e];s[e]=t}else a.extend(s,e);return this},o.use=function(e){if("string"==typeof e)try{e=t(e)}catch(i){return}var r=[].slice.call(arguments,1);return r.unshift(this),"function"==typeof e.install?e.install.apply(e,r):e.apply(null,r),this},o.require=function(e){return u[e]},o.extend=r,o.nextTick=a.nextTick,i.exports=o}),e.register("vue/src/emitter.js",function(e,t,i){function r(e){this._ctx=e||this}var n=[].slice,s=r.prototype;s.on=function(e,t){return this._cbs=this._cbs||{},(this._cbs[e]=this._cbs[e]||[]).push(t),this},s.once=function(e,t){function i(){r.off(e,i),t.apply(this,arguments)}var r=this;return this._cbs=this._cbs||{},i.fn=t,this.on(e,i),this},s.off=function(e,t){if(this._cbs=this._cbs||{},!arguments.length)return this._cbs={},this;var i=this._cbs[e];if(!i)return this;if(1===arguments.length)return delete this._cbs[e],this;for(var r,n=0;n<i.length;n++)if(r=i[n],r===t||r.fn===t){i.splice(n,1);break}return this},s.emit=function(e,t,i,r){this._cbs=this._cbs||{};var n=this._cbs[e];if(n){n=n.slice(0);for(var s=0,o=n.length;o>s;s++)n[s].call(this._ctx,t,i,r)}return this},s.applyEmit=function(e){this._cbs=this._cbs||{};var t,i=this._cbs[e];if(i){i=i.slice(0),t=n.call(arguments,1);for(var r=0,s=i.length;s>r;r++)i[r].apply(this._ctx,t)}return this},i.exports=r}),e.register("vue/src/config.js",function(e,t,i){var r=t("./text-parser");i.exports={prefix:"v",debug:!1,silent:!1,enterClass:"v-enter",leaveClass:"v-leave",interpolate:!0},Object.defineProperty(i.exports,"delimiters",{get:function(){return r.delimiters},set:function(e){r.setDelimiters(e)}})}),e.register("vue/src/utils.js",function(e,t,i){function r(e){return e.indexOf("[")<0?e:e.replace(h,".$1").replace(f,".$1")}var n,s=t("./config"),o={}.toString,a=window,c=(a.console,Object.defineProperty),l="object",u=/[^\w]this[^\w]/,h=/\['([^']+)'\]/g,f=/\["([^"]+)"\]/g,d="classList"in document.documentElement,p=a.requestAnimationFrame||a.webkitRequestAnimationFrame||a.setTimeout,v=i.exports={toFragment:t("./fragment"),parseTemplateOption:t("./template-parser.js"),get:function(e,t){if(t=r(t),t.indexOf(".")<0)return e[t];for(var i=t.split("."),n=-1,s=i.length;++n<s&&null!=e;)e=e[i[n]];return e},set:function(e,t,i){if(t=r(t),t.indexOf(".")<0)return void(e[t]=i);for(var n=t.split("."),s=-1,o=n.length-1;++s<o;)null==e[n[s]]&&(e[n[s]]={}),e=e[n[s]];e[n[s]]=i},baseKey:function(e){return e.indexOf(".")>0?e.split(".")[0]:e},hash:function(){return Object.create(null)},attr:function(e,t){var i=s.prefix+"-"+t,r=e.getAttribute(i);return null!==r&&e.removeAttribute(i),r},defProtected:function(e,t,i,r,n){c(e,t,{value:i,enumerable:r,writable:n,configurable:!0})},isObject:function(e){return typeof e===l&&e&&!Array.isArray(e)},isTrueObject:function(e){return"[object Object]"===o.call(e)},bind:function(e,t){return function(i){return e.call(t,i)}},guard:function(e){return null==e?"":"object"==typeof e?JSON.stringify(e):e},checkNumber:function(e){return isNaN(e)||null===e||"boolean"==typeof e?e:Number(e)},extend:function(e,t){for(var i in t)e[i]!==t[i]&&(e[i]=t[i]);return e},unique:function(e){for(var t,i=v.hash(),r=e.length,n=[];r--;)t=e[r],i[t]||(i[t]=1,n.push(t));return n},toConstructor:function(e){return n=n||t("./viewmodel"),v.isObject(e)?n.extend(e):"function"==typeof e?e:null},checkFilter:function(e){u.test(e.toString())&&(e.computed=!0)},processOptions:function(e){var t,i=e.components,r=e.partials,n=e.template,s=e.filters;if(i)for(t in i)i[t]=v.toConstructor(i[t]);if(r)for(t in r)r[t]=v.parseTemplateOption(r[t]);if(s)for(t in s)v.checkFilter(s[t]);n&&(e.template=v.parseTemplateOption(n))},nextTick:function(e){p(e,0)},addClass:function(e,t){if(d)e.classList.add(t);else{var i=" "+e.className+" ";i.indexOf(" "+t+" ")<0&&(e.className=(i+t).trim())}},removeClass:function(e,t){if(d)e.classList.remove(t);else{for(var i=" "+e.className+" ",r=" "+t+" ";i.indexOf(r)>=0;)i=i.replace(r," ");e.className=i.trim()}},objectToArray:function(e){var t,i,r=[];for(var n in e)t=e[n],i=v.isObject(t)?t:{$value:t},i.$key=n,r.push(i);return r}}}),e.register("vue/src/fragment.js",function(e,t,i){var r={legend:[1,"<fieldset>","</fieldset>"],tr:[2,"<table><tbody>","</tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],_default:[0,"",""]};r.td=r.th=[3,"<table><tbody><tr>","</tr></tbody></table>"],r.option=r.optgroup=[1,'<select multiple="multiple">',"</select>"],r.thead=r.tbody=r.colgroup=r.caption=r.tfoot=[1,"<table>","</table>"],r.text=r.circle=r.ellipse=r.line=r.path=r.polygon=r.polyline=r.rect=[1,'<svg xmlns="http://www.w3.org/2000/svg" version="1.1">',"</svg>"];var n=/<([\w:]+)/;i.exports=function(e){var t=document.createDocumentFragment(),i=n.exec(e);if(!i)return t.appendChild(document.createTextNode(e)),t;var s=i[1],o=r[s]||r._default,a=o[0],c=o[1],l=o[2],u=document.createElement("div");for(u.innerHTML=c+e.trim()+l;a--;)u=u.lastChild;if(u.firstChild===u.lastChild)return t.appendChild(u.firstChild),t;for(var h;h=u.firstChild;)1===u.nodeType&&t.appendChild(h);return t}}),e.register("vue/src/compiler.js",function(e,t,i){function r(e,t){var i,r,s=this;s.init=!0,s.destroyed=!1,t=s.options=t||{},l.processOptions(t),m(s,t.compilerOptions),s.repeat=s.repeat||!1,s.expCache=s.expCache||{};var a=s.el=s.setupElement(t);s.vm=a.vue_vm=e,s.bindings=l.hash(),s.dirs=[],s.deferred=[],s.computed=[],s.children=[],s.emitter=new o(e),e.$={},e.$el=a,e.$options=t,e.$compiler=s,e.$event=null;var c=t.parent;if(c&&(s.parent=c.$compiler,c.$compiler.children.push(s),e.$parent=c,"lazy"in t||(t.lazy=s.parent.options.lazy)),e.$root=n(s).vm,s.setupObserver(),t.methods)for(i in t.methods)s.createBinding(i);if(t.computed)for(i in t.computed)s.createBinding(i);var u=s.data=t.data||{},h=t.defaultData;if(h)for(i in h)g.call(u,i)||(u[i]=h[i]);var f=t.paramAttributes;if(f)for(r=f.length;r--;)u[f[r]]=l.checkNumber(s.eval(a.getAttribute(f[r])));m(e,u),e.$data=u,s.execHook("created"),u=s.data=e.$data;var p;for(i in e)p=e[i],"$"!==i.charAt(0)&&u[i]!==p&&"function"!=typeof p&&(u[i]=p);for(s.observeData(u),t.template&&this.resolveContent(),s.compile(a,!0),r=s.deferred.length;r--;)s.bindDirective(s.deferred[r]);s.deferred=null,this.computed.length&&d.parse(this.computed),s.init=!1,s.execHook("ready")}function n(e){for(;e.parent;)e=e.parent;return e}var s,o=t("./emitter"),a=t("./observer"),c=t("./config"),l=t("./utils"),u=t("./binding"),h=t("./directive"),f=t("./text-parser"),d=t("./deps-parser"),p=t("./exp-parser"),v=[].slice,m=l.extend,g={}.hasOwnProperty,b=Object.defineProperty,y=["created","ready","beforeDestroy","afterDestroy","attached","detached"],_=["if","repeat","view","component"],x=r.prototype;x.setupElement=function(e){var t,i,r,n,s,o="string"==typeof e.el?document.querySelector(e.el):e.el||document.createElement(e.tagName||"div"),a=e.template;if(a){if(o.hasChildNodes())for(this.rawContent=document.createElement("div");t=o.firstChild;)this.rawContent.appendChild(t);if(e.replace&&a.firstChild===a.lastChild){if(i=a.firstChild.cloneNode(!0),o.parentNode&&(o.parentNode.insertBefore(i,o),o.parentNode.removeChild(o)),o.hasAttributes())for(r=o.attributes.length;r--;)n=o.attributes[r],i.setAttribute(n.name,n.value);o=i}else o.appendChild(a.cloneNode(!0))}if(e.id&&(o.id=e.id),e.className&&(o.className=e.className),s=e.attributes)for(n in s)o.setAttribute(n,s[n]);return o},x.resolveContent=function(){function e(e,t){for(var i=e.parentNode,r=0,n=t.length;n>r;r++)i.insertBefore(t[r],e);i.removeChild(e)}var t,i,r,n,s,o=v.call(this.el.getElementsByTagName("content")),a=this.rawContent;if(r=o.length){for(;r--;)t=o[r],a?(i=t.getAttribute("select"),i?t.content=v.call(a.querySelectorAll(i)):s=t):t.content=v.call(t.childNodes);for(r=0,n=o.length;n>r;r++)t=o[r],t!==s&&e(t,t.content);a&&s&&e(s,v.call(a.childNodes))}this.rawContent=null},x.setupObserver=function(){function e(e){n(e),d.catcher.emit("get",a[e])}function t(e,t,i){l.emit("change:"+e,t,i),n(e),a[e].update(t)}function i(e,t){l.on("hook:"+e,function(){t.call(s.vm)})}function r(e){var t=s.children;if(t)for(var i,r=t.length;r--;)i=t[r],i.el.parentNode&&(e="hook:"+(e?"attached":"detached"),i.observer.emit(e),i.emitter.emit(e))}function n(e){a[e]||s.createBinding(e)}var s=this,a=s.bindings,c=s.options,l=s.observer=new o(s.vm);l.proxies={},l.on("get",e).on("set",t).on("mutate",t);for(var u,h,f,p=y.length;p--;)if(h=y[p],f=c[h],Array.isArray(f))for(u=f.length;u--;)i(h,f[u]);else f&&i(h,f);l.on("hook:attached",function(){r(1)}).on("hook:detached",function(){r(0)})},x.observeData=function(e){function t(e){"$data"!==e&&i()}function i(){s.update(r.data),n.emit("change:$data",r.data)}var r=this,n=r.observer;a.observe(e,"",n);var s=r.bindings.$data=new u(r,"$data");s.update(e),b(r.vm,"$data",{get:function(){return r.observer.emit("get","$data"),r.data},set:function(e){var t=r.data;a.unobserve(t,"",n),r.data=e,a.copyPaths(e,t),a.observe(e,"",n),i()}}),n.on("set",t).on("mutate",t)},x.compile=function(e,t){var i=e.nodeType;1===i&&"SCRIPT"!==e.tagName?this.compileElement(e,t):3===i&&c.interpolate&&this.compileTextNode(e)},x.checkPriorityDir=function(e,t,i){var r,n,s;if("component"===e&&i!==!0&&(s=this.resolveComponent(t,void 0,!0))?(n=this.parseDirective(e,"",t),n.Ctor=s):(r=l.attr(t,e),n=r&&this.parseDirective(e,r,t)),n){if(i===!0)return;return this.deferred.push(n),!0}},x.compileElement=function(e,t){if("TEXTAREA"===e.tagName&&e.value&&(e.value=this.eval(e.value)),e.hasAttributes()||e.tagName.indexOf("-")>-1){if(null!==l.attr(e,"pre"))return;var i,r,n,s;for(i=0,r=_.length;r>i;i++)if(this.checkPriorityDir(_[i],e,t))return;e.vue_trans=l.attr(e,"transition"),e.vue_anim=l.attr(e,"animation"),e.vue_effect=this.eval(l.attr(e,"effect"));var o,a,u,h,d,p,m,g=c.prefix+"-",b=this.options.paramAttributes;if(t){var y=l.attr(e,"with");if(y)for(d=this.parseDirective("with",y,e,!0),n=0,s=d.length;s>n;n++)this.bindDirective(d[n],this.parent)}var x=v.call(e.attributes);for(i=0,r=x.length;r>i;i++){if(o=x[i],a=o.name,u=!1,0===a.indexOf(g))for(u=!0,m=a.slice(g.length),d=this.parseDirective(m,o.value,e,!0),n=0,s=d.length;s>n;n++)this.bindDirective(d[n]);else c.interpolate&&(h=f.parseAttr(o.value),h&&(p=this.parseDirective("attr",h,e),p.arg=a,b&&b.indexOf(a)>-1?this.bindDirective(p,this.parent):this.bindDirective(p)));u&&"cloak"!==m&&e.removeAttribute(a)}}e.hasChildNodes()&&v.call(e.childNodes).forEach(this.compile,this)},x.compileTextNode=function(e){var t=f.parse(e.nodeValue);if(t){for(var i,r,n,s=0,o=t.length;o>s;s++)r=t[s],n=null,r.key?">"===r.key.charAt(0)?(i=document.createComment("ref"),n=this.parseDirective("partial",r.key.slice(1),i)):r.html?(i=document.createComment(c.prefix+"-html"),n=this.parseDirective("html",r.key,i)):(i=document.createTextNode(""),n=this.parseDirective("text",r.key,i)):i=document.createTextNode(r),e.parentNode.insertBefore(i,e),this.bindDirective(n);e.parentNode.removeChild(e)}},x.parseDirective=function(e,t,i,r){function n(t){return new h(e,t,o,s,i)}var s=this,o=s.getOption("directives",e);if(o){var a=h.parse(t);return r?a.map(n):n(a[0])}},x.bindDirective=function(e,t){if(e){if(this.dirs.push(e),e.isEmpty||e.isLiteral)return void(e.bind&&e.bind());var i,r=t||this,n=e.key;if(e.isExp)i=r.createBinding(n,e);else{for(;r&&!r.hasKey(n);)r=r.parent;r=r||this,i=r.bindings[n]||r.createBinding(n)}i.dirs.push(e),e.binding=i;var s=i.val();e.bind&&e.bind(s),e.$update(s,!0)}},x.createBinding=function(e,t){var i=this,r=i.options.methods,n=t&&t.isExp,s=t&&t.isFn||r&&r[e],o=i.bindings,c=i.options.computed,h=new u(i,e,n,s);if(n)i.defineExp(e,h,t);else if(s)o[e]=h,i.defineVmProp(e,h,r[e]);else if(o[e]=h,h.root)c&&c[e]?i.defineComputed(e,h,c[e]):"$"!==e.charAt(0)?i.defineDataProp(e,h):(i.defineVmProp(e,h,i.data[e]),delete i.data[e]);else if(c&&c[l.baseKey(e)])i.defineExp(e,h);else{a.ensurePath(i.data,e);var f=e.slice(0,e.lastIndexOf("."));o[f]||i.createBinding(f)}return h},x.defineDataProp=function(e,t){var i=this,r=i.data,n=r.__emitter__;g.call(r,e)||(r[e]=void 0),n&&!g.call(n.values,e)&&a.convertKey(r,e),t.value=r[e],b(i.vm,e,{get:function(){return i.data[e]},set:function(t){i.data[e]=t}})},x.defineVmProp=function(e,t,i){var r=this.observer;t.value=i,b(this.vm,e,{get:function(){return a.shouldGet&&r.emit("get",e),t.value},set:function(t){r.emit("set",e,t)}})},x.defineExp=function(e,t,i){var r=i&&i.computedKey,n=r?i.expression:e,s=this.expCache[n];s||(s=this.expCache[n]=p.parse(r||e,this)),s&&this.markComputed(t,s)},x.defineComputed=function(e,t,i){this.markComputed(t,i),b(this.vm,e,{get:t.value.$get,set:t.value.$set})},x.markComputed=function(e,t){e.isComputed=!0,e.isFn?e.value=t:("function"==typeof t&&(t={$get:t}),e.value={$get:l.bind(t.$get,this.vm),$set:t.$set?l.bind(t.$set,this.vm):void 0}),this.computed.push(e)},x.getOption=function(e,t,i){var r=this.options,n=this.parent,s=c.globalAssets,o=r[e]&&r[e][t]||(n?n.getOption(e,t,i):s[e]&&s[e][t]);return o},x.execHook=function(e){e="hook:"+e,this.observer.emit(e),this.emitter.emit(e)},x.hasKey=function(e){var t=l.baseKey(e);return g.call(this.data,t)||g.call(this.vm,t)},x.eval=function(e,t){var i=f.parseAttr(e);return i?p.eval(i,this,t):e},x.resolveComponent=function(e,i,r){s=s||t("./viewmodel");var n=l.attr(e,"component"),o=e.tagName,a=this.eval(n,i),c=o.indexOf("-")>0&&o.toLowerCase(),u=this.getOption("components",a||c,!0);return r?""===n?s:u:u||s},x.destroy=function(e){if(!this.destroyed){var t,i,r,n,s,o,c=this,l=c.vm,u=c.el,h=c.dirs,f=c.computed,d=c.bindings,p=c.children,v=c.parent;for(c.execHook("beforeDestroy"),a.unobserve(c.data,"",c.observer),t=p.length;t--;)p[t].destroy(!0);for(t=h.length;t--;)n=h[t],n.binding&&n.binding.compiler!==c&&(s=n.binding.dirs,s&&(i=s.indexOf(n),i>-1&&s.splice(i,1))),n.$unbind();for(t=f.length;t--;)f[t].unbind();for(r in d)o=d[r],o&&o.unbind();v&&(i=v.children.indexOf(c),i>-1&&v.children.splice(i,1)),e||(u===document.body?u.innerHTML="":l.$remove()),u.vue_vm=null,c.destroyed=!0,c.execHook("afterDestroy"),c.observer.off(),c.emitter.off()}},i.exports=r}),e.register("vue/src/viewmodel.js",function(e,t,i){function r(e){e!==!1&&new s(this,e)}function n(e){return"string"==typeof e?document.querySelector(e):e}var s=t("./compiler"),o=t("./utils"),a=t("./transition"),c=t("./batcher"),l=[].slice,u=o.defProtected,h=o.nextTick,f=new c,d=1,p=r.prototype;u(p,"$init",function(e){new s(this,e)}),u(p,"$get",function(e){var t=o.get(this,e);return void 0===t&&this.$parent?this.$parent.$get(e):t}),u(p,"$set",function(e,t){o.set(this,e,t)}),u(p,"$watch",function(e,t){function i(){var e=l.call(arguments);f.push({id:r,override:!0,execute:function(){t.apply(n,e)}})}var r=d++,n=this;t._fn=i,n.$compiler.observer.on("change:"+e,i)}),u(p,"$unwatch",function(e,t){var i=["change:"+e],r=this.$compiler.observer;t&&i.push(t._fn),r.off.apply(r,i)}),u(p,"$destroy",function(e){this.$compiler.destroy(e)}),u(p,"$broadcast",function(){for(var e,t=this.$compiler.children,i=t.length;i--;)e=t[i],e.emitter.applyEmit.apply(e.emitter,arguments),e.vm.$broadcast.apply(e.vm,arguments)}),u(p,"$dispatch",function(){var e=this.$compiler,t=e.emitter,i=e.parent;t.applyEmit.apply(t,arguments),i&&i.vm.$dispatch.apply(i.vm,arguments)}),["emit","on","off","once"].forEach(function(e){var t="emit"===e?"applyEmit":e;u(p,"$"+e,function(){var e=this.$compiler.emitter;e[t].apply(e,arguments)})}),u(p,"$appendTo",function(e,t){e=n(e);var i=this.$el;a(i,1,function(){e.appendChild(i),t&&h(t)},this.$compiler)}),u(p,"$remove",function(e){var t=this.$el;a(t,-1,function(){t.parentNode&&t.parentNode.removeChild(t),e&&h(e)},this.$compiler)}),u(p,"$before",function(e,t){e=n(e);var i=this.$el;a(i,1,function(){e.parentNode.insertBefore(i,e),t&&h(t)},this.$compiler)}),u(p,"$after",function(e,t){e=n(e);var i=this.$el;a(i,1,function(){e.nextSibling?e.parentNode.insertBefore(i,e.nextSibling):e.parentNode.appendChild(i),t&&h(t)},this.$compiler)}),i.exports=r}),e.register("vue/src/binding.js",function(e,t,i){function r(e,t,i,r){this.id=o++,this.value=void 0,this.isExp=!!i,this.isFn=r,this.root=!this.isExp&&-1===t.indexOf("."),this.compiler=e,this.key=t,this.dirs=[],this.subs=[],this.deps=[],this.unbound=!1}var n=t("./batcher"),s=new n,o=1,a=r.prototype;a.update=function(e){if((!this.isComputed||this.isFn)&&(this.value=e),this.dirs.length||this.subs.length){var t=this;s.push({id:this.id,execute:function(){t.unbound||t._update()}})}},a._update=function(){for(var e=this.dirs.length,t=this.val();e--;)this.dirs[e].$update(t);this.pub()},a.val=function(){return this.isComputed&&!this.isFn?this.value.$get():this.value},a.pub=function(){for(var e=this.subs.length;e--;)this.subs[e].update()},a.unbind=function(){this.unbound=!0;for(var e=this.dirs.length;e--;)this.dirs[e].$unbind();e=this.deps.length;for(var t;e--;){t=this.deps[e].subs;var i=t.indexOf(this);i>-1&&t.splice(i,1)}},i.exports=r}),e.register("vue/src/observer.js",function(e,t,i){function r(e){x(O,e,function(){var t,i,r=E.call(arguments),o=Array.prototype[e].apply(this,r);return"push"===e||"unshift"===e?t=r:"pop"===e||"shift"===e?i=[o]:"splice"===e&&(t=r.slice(2),i=o),n(this,t),s(this,i),this.__emitter__.emit("mutate","",this,{method:e,args:r,result:o,inserted:t,removed:i}),o},!A)}function n(e,t){if(t)for(var i,r,n=t.length;n--;)i=t[n],o(i)&&(i.__emitter__||(a(i),l(i)),r=i.__emitter__.owners,r.indexOf(e)<0&&r.push(e))}function s(e,t){if(t)for(var i,r=t.length;r--;)if(i=t[r],i&&i.__emitter__){var n=i.__emitter__.owners;n&&n.splice(n.indexOf(e))}}function o(e){return"object"==typeof e&&e&&!e.$compiler}function a(e){if(e.__emitter__)return!0;var t=new y;return x(e,"__emitter__",t),t.on("set",function(t,i,r){r&&c(e)}).on("mutate",function(){c(e)}),t.values=_.hash(),t.owners=[],!1}function c(e){for(var t=e.__emitter__.owners,i=t.length;i--;)t[i].__emitter__.emit("set","","",!0)}function l(e){k(e)?f(e):h(e)}function u(e,t){if(A)e.__proto__=t;else for(var i in t)x(e,i,t[i])}function h(e){u(e,j);for(var t in e)d(e,t)}function f(e){u(e,O),n(e,e)}function d(e,t,i){function r(e,i){o[t]=e,s.emit("set",t,e,i),k(e)&&s.emit("set",t+".length",e.length,i),g(e,t,s)}var n=t.charAt(0);if("$"!==n&&"_"!==n){var s=e.__emitter__,o=s.values;r(e[t],i),C(e,t,{enumerable:!0,configurable:!0,get:function(){var e=o[t];return N.shouldGet&&s.emit("get",t),e},set:function(e){var i=o[t];b(i,t,s),v(e,i),r(e,!0)}})}}function p(e){var t=e&&e.__emitter__;if(t)if(k(e))t.emit("set","length",e.length);else{var i,r;for(i in e)r=e[i],t.emit("set",i,r),p(r)}}function v(e,t){if($(e)&&$(t)){var i,r,n;for(i in t)w.call(e,i)||(r=t[i],k(r)?e[i]=[]:$(r)?(n=e[i]={},v(n,r)):e[i]=void 0)}}function m(e,t){for(var i,r=t.split("."),n=0,s=r.length-1;s>n;n++)i=r[n],e[i]||(e[i]={},e.__emitter__&&d(e,i)),e=e[i];$(e)&&(i=r[n],w.call(e,i)||(e[i]=void 0,e.__emitter__&&d(e,i)))}function g(e,t,i){if(o(e)){var r=t?t+".":"",n=a(e),s=e.__emitter__;i.proxies=i.proxies||{};var c=i.proxies[r]={get:function(e){i.emit("get",r+e)},set:function(n,s,o){n&&i.emit("set",r+n,s),t&&o&&i.emit("set",t,e,!0)},mutate:function(e,n,s){var o=e?r+e:t;i.emit("mutate",o,n,s);var a=s.method;"sort"!==a&&"reverse"!==a&&i.emit("set",o+".length",n.length)}};s.on("get",c.get).on("set",c.set).on("mutate",c.mutate),n?p(e):l(e)}}function b(e,t,i){if(e&&e.__emitter__){t=t?t+".":"";var r=i.proxies[t];r&&(e.__emitter__.off("get",r.get).off("set",r.set).off("mutate",r.mutate),i.proxies[t]=null)}}var y=t("./emitter"),_=t("./utils"),x=_.defProtected,$=_.isObject,k=Array.isArray,w={}.hasOwnProperty,C=Object.defineProperty,E=[].slice,A={}.__proto__,O=Object.create(Array.prototype);["push","pop","shift","unshift","splice","sort","reverse"].forEach(r),x(O,"$set",function(e,t){return this.splice(e,1,t)[0]},!A),x(O,"$remove",function(e){return"number"!=typeof e&&(e=this.indexOf(e)),e>-1?this.splice(e,1)[0]:void 0},!A);var j=Object.create(Object.prototype);x(j,"$add",function(e,t){w.call(this,e)||(this[e]=t,d(this,e,!0))},!A),x(j,"$delete",function(e){w.call(this,e)&&(this[e]=void 0,delete this[e],this.__emitter__.emit("delete",e))},!A);var N=i.exports={shouldGet:!1,observe:g,unobserve:b,ensurePath:m,copyPaths:v,watch:l,convert:a,convertKey:d}}),e.register("vue/src/directive.js",function(e,t,i){function r(e,t,i,n,o){this.id=s++,this.name=e,this.compiler=n,this.vm=n.vm,this.el=o,this.computeFilters=!1,this.key=t.key,this.arg=t.arg,this.expression=t.expression;var a=""===this.expression;if("function"==typeof i)this[a?"bind":"update"]=i;else for(var u in i)this[u]=i[u];if(a||this.isEmpty)return void(this.isEmpty=!0);h.Regex.test(this.key)&&(this.key=n.eval(this.key),this.isLiteral&&(this.expression=this.key));var f,d,p,v,m,g=t.filters;if(g)for(this.filters=[],p=0,v=g.length;v>p;p++)f=g[p],d=this.compiler.getOption("filters",f.name),d&&(f.apply=d,this.filters.push(f),d.computed&&(m=!0));this.filters&&this.filters.length||(this.filters=null),m&&(this.computedKey=r.inlineFilters(this.key,this.filters),this.filters=null),this.isExp=m||!l.test(this.key)||c.test(this.key)}function n(e){return e.indexOf('"')>-1?e.replace(u,"'"):e}var s=1,o=/^[\w\$-]+$/,a=/[^\s'"]+|'[^']+'|"[^"]+"/g,c=/^\$(parent|root)\./,l=/^[\w\.$]+$/,u=/"/g,h=t("./text-parser"),f=r.prototype;f.$update=function(e,t){this.$lock||(t||e!==this.value||e&&"object"==typeof e)&&(this.value=e,this.update&&this.update(this.filters&&!this.computeFilters?this.$applyFilters(e):e,t))},f.$applyFilters=function(e){for(var t,i=e,r=0,n=this.filters.length;n>r;r++)t=this.filters[r],i=t.apply.apply(this.vm,[i].concat(t.args));return i},f.$unbind=function(){this.el&&this.vm&&(this.unbind&&this.unbind(),this.vm=this.el=this.binding=this.compiler=null)},r.parse=function(e){function t(){v.expression=e.slice(f,g).trim(),void 0===v.key?v.key=e.slice(d,g).trim():m!==f&&i(),(0===g||v.key)&&p.push(v)}function i(){var t,i=e.slice(m,g).trim();if(i){t={};var r=i.match(a);t.name=r[0],t.args=r.length>1?r.slice(1):null}t&&(v.filters=v.filters||[]).push(t),m=g+1}for(var r,n,s=!1,c=!1,l=0,u=0,h=0,f=0,d=0,p=[],v={},m=0,g=0,b=e.length;b>g;g++)n=e.charAt(g),s?"'"===n&&(s=!s):c?'"'===n&&(c=!c):","!==n||h||l||u?":"!==n||v.key||v.arg?"|"===n&&"|"!==e.charAt(g+1)&&"|"!==e.charAt(g-1)?void 0===v.key?(m=g+1,v.key=e.slice(d,g).trim()):i():'"'===n?c=!0:"'"===n?s=!0:"("===n?h++:")"===n?h--:"["===n?u++:"]"===n?u--:"{"===n?l++:"}"===n&&l--:(r=e.slice(f,g).trim(),o.test(r)&&(d=g+1,v.arg=r)):(t(),v={},f=d=m=g+1);return(0===g||f!==g)&&t(),p},r.inlineFilters=function(e,t){for(var i,r,s=0,o=t.length;o>s;s++)r=t[s],i=r.args?',"'+r.args.map(n).join('","')+'"':"",e='this.$compiler.getOption("filters", "'+r.name+'").call(this,'+e+i+")";return e},i.exports=r}),e.register("vue/src/exp-parser.js",function(e,t){function i(e){return e=e.replace(p,"").replace(v,",").replace(d,"").replace(m,"").replace(g,""),e?e.split(/,+/):[]}function r(e,t,i){var r="",n=0,s=t;if(i&&void 0!==o.get(i,e))return"$temp.";for(;t&&!t.hasKey(e);)t=t.parent,n++;if(t){for(;n--;)r+="$parent.";t.bindings[e]||"$"===e.charAt(0)||t.createBinding(e)}else s.createBinding(e);return r}function n(e,t){var i;try{i=new Function(e)}catch(r){}return i}function s(e){return"$"===e.charAt(0)?"\\"+e:e}var o=t("./utils"),a=/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g,c=/"(\d+)"/g,l=/\n/g,u=new RegExp("constructor".split("").join("['\"+, ]*")),h=/\\u\d\d\d\d/,f="break,case,catch,continue,debugger,default,delete,do,else,false,finally,for,function,if,in,instanceof,new,null,return,switch,this,throw,true,try,typeof,var,void,while,with,undefined,abstract,boolean,byte,char,class,const,double,enum,export,extends,final,float,goto,implements,import,int,interface,long,native,package,private,protected,public,short,static,super,synchronized,throws,transient,volatile,arguments,let,yield,Math",d=new RegExp(["\\b"+f.replace(/,/g,"\\b|\\b")+"\\b"].join("|"),"g"),p=/\/\*(?:.|\n)*?\*\/|\/\/[^\n]*\n|\/\/[^\n]*$|'[^']*'|"[^"]*"|[\s\t\n]*\.[\s\t\n]*[$\w\.]+|[\{,]\s*[\w\$_]+\s*:/g,v=/[^\w$]+/g,m=/\b\d[^,]*/g,g=/^,+|,+$/g;e.parse=function(e,t,f){function d(e){var t=y.length;return y[t]=e.replace(l,"\\n"),'"'+t+'"'}function p(e){var i=e.charAt(0);e=e.slice(1);var n="this."+r(e,t,f)+e;return b[e]||(g+=n+";",b[e]=1),i+n}function v(e,t){return y[t]}if(!h.test(e)&&!u.test(e)){var m=i(e);if(!m.length)return n("return "+e,e);m=o.unique(m);var g="",b=o.hash(),y=[],_=new RegExp("[^$\\w\\.]("+m.map(s).join("|")+")[$\\w\\.]*\\b","g"),x=(" "+e).replace(a,d).replace(_,p).replace(c,v);return x=g+"return "+x,n(x,e)}},e.eval=function(t,i,r){var n,s=e.parse(t,i,r);return s&&(i.vm.$temp=r,n=s.call(i.vm),delete i.vm.$temp),n}}),e.register("vue/src/template-parser.js",function(e,t,i){var r=t("./fragment");i.exports=function(e){var t;if(e instanceof window.DocumentFragment)return e;if("string"==typeof e){if("#"!==e.charAt(0))return r(e);if(t=document.getElementById(e.slice(1)),!t)return}else{if(!e.nodeType)return;t=e}return"TEMPLATE"===t.tagName&&t.content?t.content:r("SCRIPT"===t.tagName?t.innerHTML:t.outerHTML)}}),e.register("vue/src/text-parser.js",function(e,t){function i(){var e=r(l),t=r(u);return new RegExp(e+e+e+"?(.+?)"+t+"?"+t+t)}function r(e){return e.replace(h,"\\$&")}function n(t){l=t[0],u=t[1],e.delimiters=t,e.Regex=i()}function s(t){if(!e.Regex.test(t))return null;for(var i,r,n,s,o=[];i=t.match(e.Regex);)r=i.index,r>0&&o.push(t.slice(0,r)),n={key:i[1].trim()},s=i[0],n.html=s.charAt(2)===l&&s.charAt(s.length-3)===u,o.push(n),t=t.slice(r+i[0].length);return t.length&&o.push(t),o}function o(e){c=c||t("./directive");var i=s(e);if(!i)return null;if(1===i.length)return i[0].key;for(var r,n=[],o=0,l=i.length;l>o;o++)r=i[o],n.push(r.key?a(r.key):'"'+r+'"');return n.join("+")}function a(e){if(e.indexOf("|")>-1){var t=c.parse(e),i=t&&t[0];i&&i.filters&&(e=c.inlineFilters(i.key,i.filters))}return"("+e+")"}var c,l="{",u="}",h=/[-.*+?^${}()|[\]\/\\]/g;e.Regex=i(),e.parse=s,e.parseAttr=o,e.setDelimiters=n,e.delimiters=[l,u]}),e.register("vue/src/deps-parser.js",function(e,t,i){function r(e){if(!e.isFn){var t=o.hash();e.deps=[],c.on("get",function(i){var r=t[i.key];r&&r.compiler===i.compiler||i.compiler.repeat&&!n(i.compiler,e.compiler)||(t[i.key]=i,e.deps.push(i),i.subs.push(e))}),e.value.$get(),c.off("get")}}function n(e,t){for(;t;){if(e===t)return!0;t=t.parent}}var s=t("./emitter"),o=t("./utils"),a=t("./observer"),c=new s;i.exports={catcher:c,parse:function(e){a.shouldGet=!0,e.forEach(r),a.shouldGet=!1}}}),e.register("vue/src/filters.js",function(e,t,i){function r(e,t){if(s.isObject(e)){for(var i in e)if(r(e[i],t))return!0}else if(null!=e)return e.toString().toLowerCase().indexOf(t)>-1}function n(e){return c.test(e)?e.slice(1,-1):void 0}var s=t("./utils"),o=s.get,a=[].slice,c=/^'.*'$/,l=i.exports=s.hash();l.capitalize=function(e){return e||0===e?(e=e.toString(),e.charAt(0).toUpperCase()+e.slice(1)):""},l.uppercase=function(e){return e||0===e?e.toString().toUpperCase():""},l.lowercase=function(e){return e||0===e?e.toString().toLowerCase():""},l.currency=function(e,t){if(e=parseFloat(e),!e&&0!==e)return"";t=t||"$";var i=Math.floor(e).toString(),r=i.length%3,n=r>0?i.slice(0,r)+(i.length>3?",":""):"",s="."+e.toFixed(2).slice(-2);return t+n+i.slice(r).replace(/(\d{3})(?=\d)/g,"$1,")+s},l.pluralize=function(e){var t=a.call(arguments,1);return t.length>1?t[e-1]||t[t.length-1]:t[e-1]||t[0]+"s"};var u={enter:13,tab:9,"delete":46,up:38,left:37,right:39,down:40,esc:27};l.key=function(e,t){if(e){var i=u[t];return i||(i=parseInt(t,10)),function(t){return t.keyCode===i?e.call(this,t):void 0}}},l.filterBy=function(e,t,i,a){i&&"in"!==i&&(a=i);var c=n(t)||this.$get(t);return c?(c=c.toLowerCase(),a=a&&(n(a)||this.$get(a)),Array.isArray(e)||(e=s.objectToArray(e)),e.filter(function(e){return a?r(o(e,a),c):r(e,c)})):e},l.filterBy.computed=!0,l.orderBy=function(e,t,i){var r=n(t)||this.$get(t);if(!r)return e;Array.isArray(e)||(e=s.objectToArray(e));var a=1;return i&&("-1"===i?a=-1:"!"===i.charAt(0)?(i=i.slice(1),a=this.$get(i)?1:-1):a=this.$get(i)?-1:1),e.slice().sort(function(e,t){return e=o(e,r),t=o(t,r),e===t?0:e>t?a:-a})},l.orderBy.computed=!0}),e.register("vue/src/transition.js",function(e,t,i){function r(e,t,i,r){if(!o.trans)return i(),f.CSS_SKIP;var n,s=e.classList,c=e.vue_trans_cb,u=a.enterClass,h=a.leaveClass,d=r?o.anim:o.trans;return c&&(e.removeEventListener(d,c),s.remove(u),s.remove(h),e.vue_trans_cb=null),t>0?(s.add(u),i(),r?(n=function(t){t.target===e&&(e.removeEventListener(d,n),e.vue_trans_cb=null,s.remove(u))},e.addEventListener(d,n),e.vue_trans_cb=n):l.push({execute:function(){s.remove(u)}}),f.CSS_E):(e.offsetWidth||e.offsetHeight?(s.add(h),n=function(t){t.target===e&&(e.removeEventListener(d,n),e.vue_trans_cb=null,i(),s.remove(h))},e.addEventListener(d,n),e.vue_trans_cb=n):i(),f.CSS_L)}function n(e,t,i,r,n){function s(t,i){var r=u(function(){t(),l.splice(l.indexOf(r),1),l.length||(e.vue_timeouts=null)},i);l.push(r)}var o=n.getOption("effects",r);if(!o)return i(),f.JS_SKIP;var a=o.enter,c=o.leave,l=e.vue_timeouts;if(l)for(var d=l.length;d--;)h(l[d]);return l=e.vue_timeouts=[],t>0?"function"!=typeof a?(i(),f.JS_SKIP_E):(a(e,i,s),f.JS_E):"function"!=typeof c?(i(),f.JS_SKIP_L):(c(e,i,s),f.JS_L)}function s(){var e=document.createElement("vue"),t="transitionend",i={webkitTransition:"webkitTransitionEnd",transition:t,mozTransition:t},r={};for(var n in i)if(void 0!==e.style[n]){r.trans=i[n];break}return r.anim=""===e.style.animation?"animationend":"webkitAnimationEnd",r}var o=s(),a=t("./config"),c=t("./batcher"),l=new c,u=window.setTimeout,h=window.clearTimeout,f={CSS_E:1,CSS_L:2,JS_E:3,JS_L:4,CSS_SKIP:-1,JS_SKIP:-2,JS_SKIP_E:-3,JS_SKIP_L:-4,INIT:-5,SKIP:-6};l._preFlush=function(){document.body.offsetHeight};var d=i.exports=function(e,t,i,s){var o=function(){i(),s.execHook(t>0?"attached":"detached")
-};if(s.init)return o(),f.INIT;var a=""===e.vue_trans,c=""===e.vue_anim,l=e.vue_effect;return l?n(e,t,o,l,s):a||c?r(e,t,o,c):(o(),f.SKIP)};d.codes=f,d.sniff=s}),e.register("vue/src/batcher.js",function(e,t,i){function r(){this.reset()}var n=t("./utils"),s=r.prototype;s.push=function(e){if(e.id&&this.has[e.id]){if(e.override){var t=this.has[e.id];t.cancelled=!0,this.queue.push(e),this.has[e.id]=e}}else this.queue.push(e),this.has[e.id]=e,this.waiting||(this.waiting=!0,n.nextTick(n.bind(this.flush,this)))},s.flush=function(){this._preFlush&&this._preFlush();for(var e=0;e<this.queue.length;e++){var t=this.queue[e];t.cancelled||t.execute()}this.reset()},s.reset=function(){this.has=n.hash(),this.queue=[],this.waiting=!1},i.exports=r}),e.register("vue/src/directives/index.js",function(e,t,i){var r=t("../utils"),n=t("../config"),s=t("../transition"),o=i.exports=r.hash();o.component={isLiteral:!0,bind:function(){this.el.vue_vm||(this.childVM=new this.Ctor({el:this.el,parent:this.vm}))},unbind:function(){this.childVM&&this.childVM.$destroy()}},o.attr={bind:function(){var e=this.vm.$options.paramAttributes;this.isParam=e&&e.indexOf(this.arg)>-1},update:function(e){e||0===e?this.el.setAttribute(this.arg,e):this.el.removeAttribute(this.arg),this.isParam&&(this.vm[this.arg]=r.checkNumber(e))}},o.text={bind:function(){this.attr=3===this.el.nodeType?"nodeValue":"textContent"},update:function(e){this.el[this.attr]=r.guard(e)}},o.show=function(e){var t=this.el,i=e?"":"none",r=function(){t.style.display=i};s(t,e?1:-1,r,this.compiler)},o["class"]=function(e){this.arg?r[e?"addClass":"removeClass"](this.el,this.arg):(this.lastVal&&r.removeClass(this.el,this.lastVal),e&&(r.addClass(this.el,e),this.lastVal=e))},o.cloak={isEmpty:!0,bind:function(){var e=this.el;this.compiler.observer.once("hook:ready",function(){e.removeAttribute(n.prefix+"-cloak")})}},o.ref={isLiteral:!0,bind:function(){var e=this.expression;e&&(this.vm.$parent.$[e]=this.vm)},unbind:function(){var e=this.expression;e&&delete this.vm.$parent.$[e]}},o.on=t("./on"),o.repeat=t("./repeat"),o.model=t("./model"),o["if"]=t("./if"),o["with"]=t("./with"),o.html=t("./html"),o.style=t("./style"),o.partial=t("./partial"),o.view=t("./view")}),e.register("vue/src/directives/if.js",function(e,t,i){var r=t("../utils");i.exports={bind:function(){this.parent=this.el.parentNode,this.ref=document.createComment("vue-if"),this.Ctor=this.compiler.resolveComponent(this.el),this.parent.insertBefore(this.ref,this.el),this.parent.removeChild(this.el),r.attr(this.el,"view"),r.attr(this.el,"repeat")},update:function(e){e?this.childVM||(this.childVM=new this.Ctor({el:this.el.cloneNode(!0),parent:this.vm}),this.compiler.init?this.parent.insertBefore(this.childVM.$el,this.ref):this.childVM.$before(this.ref)):this.unbind()},unbind:function(){this.childVM&&(this.childVM.$destroy(),this.childVM=null)}}}),e.register("vue/src/directives/repeat.js",function(e,t,i){function r(e,t){for(var i,r=0,n=e.length;n>r;r++)if(i=e[r],!i.$reused&&i.$value===t)return r;return-1}var n=t("../utils"),s=t("../config");i.exports={bind:function(){this.identifier="$r"+this.id,this.expCache=n.hash();var e=this.el,t=this.container=e.parentNode;this.childId=this.compiler.eval(n.attr(e,"ref")),this.ref=document.createComment(s.prefix+"-repeat-"+this.key),t.insertBefore(this.ref,e),t.removeChild(e),this.collection=null,this.vms=null},update:function(e){Array.isArray(e)||n.isObject(e)&&(e=n.objectToArray(e)),this.oldVMs=this.vms,this.oldCollection=this.collection,e=this.collection=e||[];var t=e[0]&&n.isObject(e[0]);this.vms=this.oldCollection?this.diff(e,t):this.init(e,t),this.childId&&(this.vm.$[this.childId]=this.vms)},init:function(e,t){for(var i,r=[],n=0,s=e.length;s>n;n++)i=this.build(e[n],n,t),r.push(i),this.compiler.init?this.container.insertBefore(i.$el,this.ref):i.$before(this.ref);return r},diff:function(e,t){var i,n,s,o,a,c,l,u,h=this.container,f=this.oldVMs,d=[];for(d.length=e.length,i=0,n=e.length;n>i;i++)s=e[i],t?(s.$index=i,s.__emitter__&&s.__emitter__[this.identifier]?s.$reused=!0:d[i]=this.build(s,i,t)):(a=r(f,s),a>-1?(f[a].$reused=!0,f[a].$data.$index=i):d[i]=this.build(s,i,t));for(i=0,n=f.length;n>i;i++)o=f[i],s=this.arg?o.$data[this.arg]:o.$data,s.$reused&&(o.$reused=!0,delete s.$reused),o.$reused?(o.$index=s.$index,s.$key&&s.$key!==o.$key&&(o.$key=s.$key),d[o.$index]=o):(s.__emitter__&&delete s.__emitter__[this.identifier],o.$destroy());for(i=d.length;i--;)if(o=d[i],s=o.$data,c=d[i+1],o.$reused){for(u=o.$el.nextSibling;!u.vue_vm&&u!==this.ref;)u=u.nextSibling;if(l=u.vue_vm,l!==c)if(c){for(u=c.$el;!u.parentNode;)c=d[u.vue_vm.$index+1],u=c?c.$el:this.ref;h.insertBefore(o.$el,u)}else h.insertBefore(o.$el,this.ref);delete o.$reused,delete s.$index,delete s.$key}else o.$before(c?c.$el:this.ref);return d},build:function(e,t,i){var r,n,s=!i||this.arg;s&&(r=e,n=this.arg||"$value",e={},e[n]=r),e.$index=t;var o=this.el.cloneNode(!0),a=this.compiler.resolveComponent(o,e),c=new a({el:o,data:e,parent:this.vm,compilerOptions:{repeat:!0,expCache:this.expCache}});return i&&((r||e).__emitter__[this.identifier]=!0),c},unbind:function(){if(this.childId&&delete this.vm.$[this.childId],this.vms)for(var e=this.vms.length;e--;)this.vms[e].$destroy()}}}),e.register("vue/src/directives/on.js",function(e,t,i){t("../utils");i.exports={isFn:!0,bind:function(){if(this.context=this.binding.isExp?this.vm:this.binding.compiler.vm,"IFRAME"===this.el.tagName&&"load"!==this.arg){var e=this;this.iframeBind=function(){e.el.contentWindow.addEventListener(e.arg,e.handler)},this.el.addEventListener("load",this.iframeBind)}},update:function(e){if("function"==typeof e){this.reset();var t=this.vm,i=this.context;this.handler=function(r){r.targetVM=t,i.$event=r;var n=e.call(i,r);return i.$event=null,n},this.iframeBind?this.iframeBind():this.el.addEventListener(this.arg,this.handler)}},reset:function(){var e=this.iframeBind?this.el.contentWindow:this.el;this.handler&&e.removeEventListener(this.arg,this.handler)},unbind:function(){this.reset(),this.el.removeEventListener("load",this.iframeBind)}}}),e.register("vue/src/directives/model.js",function(e,t,i){function r(e){return o.call(e.options,function(e){return e.selected}).map(function(e){return e.value||e.text})}var n=t("../utils"),s=navigator.userAgent.indexOf("MSIE 9.0")>0,o=[].filter;i.exports={bind:function(){var e=this,t=e.el,i=t.type,r=t.tagName;e.lock=!1,e.ownerVM=e.binding.compiler.vm,e.event=e.compiler.options.lazy||"SELECT"===r||"checkbox"===i||"radio"===i?"change":"input",e.attr="checkbox"===i?"checked":"INPUT"===r||"SELECT"===r||"TEXTAREA"===r?"value":"innerHTML","SELECT"===r&&t.hasAttribute("multiple")&&(this.multi=!0);var o=!1;e.cLock=function(){o=!0},e.cUnlock=function(){o=!1},t.addEventListener("compositionstart",this.cLock),t.addEventListener("compositionend",this.cUnlock),e.set=e.filters?function(){if(!o){var i;try{i=t.selectionStart}catch(r){}e._set(),n.nextTick(function(){void 0!==i&&t.setSelectionRange(i,i)})}}:function(){o||(e.lock=!0,e._set(),n.nextTick(function(){e.lock=!1}))},t.addEventListener(e.event,e.set),s&&(e.onCut=function(){n.nextTick(function(){e.set()})},e.onDel=function(t){(46===t.keyCode||8===t.keyCode)&&e.set()},t.addEventListener("cut",e.onCut),t.addEventListener("keyup",e.onDel))},_set:function(){this.ownerVM.$set(this.key,this.multi?r(this.el):this.el[this.attr])},update:function(e,t){if(t&&void 0===e)return this._set();if(!this.lock){var i=this.el;"SELECT"===i.tagName?(i.selectedIndex=-1,this.multi&&Array.isArray(e)?e.forEach(this.updateSelect,this):this.updateSelect(e)):"radio"===i.type?i.checked=e==i.value:"checkbox"===i.type?i.checked=!!e:i[this.attr]=n.guard(e)}},updateSelect:function(e){for(var t=this.el.options,i=t.length;i--;)if(t[i].value==e){t[i].selected=!0;break}},unbind:function(){var e=this.el;e.removeEventListener(this.event,this.set),e.removeEventListener("compositionstart",this.cLock),e.removeEventListener("compositionend",this.cUnlock),s&&(e.removeEventListener("cut",this.onCut),e.removeEventListener("keyup",this.onDel))}}}),e.register("vue/src/directives/with.js",function(e,t,i){var r=t("../utils");i.exports={bind:function(){var e=this,t=e.arg,i=e.key,n=e.compiler,s=e.binding.compiler;return n===s?void(this.alone=!0):void(t&&(n.bindings[t]||n.createBinding(t),n.observer.on("change:"+t,function(t){n.init||(e.lock||(e.lock=!0,r.nextTick(function(){e.lock=!1})),s.vm.$set(i,t))})))},update:function(e){this.alone||this.lock||(this.arg?this.vm.$set(this.arg,e):this.vm.$data!==e&&(this.vm.$data=e))}}}),e.register("vue/src/directives/html.js",function(e,t,i){var r=t("../utils"),n=[].slice;i.exports={bind:function(){8===this.el.nodeType&&(this.nodes=[])},update:function(e){e=r.guard(e),this.nodes?this.swap(e):this.el.innerHTML=e},swap:function(e){for(var t=this.el.parentNode,i=this.nodes,s=i.length;s--;)t.removeChild(i[s]);var o=r.toFragment(e);this.nodes=n.call(o.childNodes),t.insertBefore(o,this.el)}}}),e.register("vue/src/directives/style.js",function(e,t,i){var r=["-webkit-","-moz-","-ms-"];i.exports={bind:function(){var e=this.arg;e&&("$"===e.charAt(0)&&(e=e.slice(1),this.prefixed=!0),this.prop=e)},update:function(e){var t,i=this.prop;if(null!=e&&(e+=""),i){if(e&&(t="!important"===e.slice(-10)?"important":"",t&&(e=e.slice(0,-10).trim())),this.el.style.setProperty(i,e,t),this.prefixed)for(var n=r.length;n--;)this.el.style.setProperty(r[n]+i,e,t)}else this.el.style.cssText=e}}}),e.register("vue/src/directives/partial.js",function(e,t,i){t("../utils");i.exports={isLiteral:!0,bind:function(){var e=this.expression;if(e){var t=this.el,i=this.compiler,r=i.getOption("partials",e);if(r)if(r=r.cloneNode(!0),8===t.nodeType){var n=[].slice.call(r.childNodes),s=t.parentNode;s.insertBefore(r,t),s.removeChild(t),n.forEach(i.compile,i)}else t.innerHTML="",t.appendChild(r)}}}}),e.register("vue/src/directives/view.js",function(e,t,i){i.exports={bind:function(){var e=this.raw=this.el,t=e.parentNode,i=this.ref=document.createComment("v-view");t.insertBefore(i,e),t.removeChild(e);for(var r,n=this.inner=document.createElement("div");r=e.firstChild;)n.appendChild(r)},update:function(e){this.unbind();var t=this.compiler.getOption("components",e);t&&(this.childVM=new t({el:this.raw.cloneNode(!0),parent:this.vm,compilerOptions:{rawContent:this.inner.cloneNode(!0)}}),this.el=this.childVM.$el,this.compiler.init?this.ref.parentNode.insertBefore(this.el,this.ref):this.childVM.$before(this.ref))},unbind:function(){this.childVM&&this.childVM.$destroy()}}}),e.alias("vue/src/main.js","vue/index.js"),"object"==typeof exports?module.exports=e("vue"):"function"==typeof define&&define.amd?define(function(){return e("vue")}):window.Vue=e("vue")}();
\ No newline at end of file
+/**
+ * Vue.js v0.11.0
+ * (c) 2014 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(n){if(i[n])return i[n].exports;var r=i[n]={exports:{},id:n,loaded:!1};return t[n].call(r.exports,r,r.exports,e),r.loaded=!0,r.exports}var i={};return e.m=t,e.c=i,e.p="",e(0)}([function(t,e,i){function n(t){this._init(t)}var r=i(1),s=r.extend;s(n,i(2)),n.options={directives:i(8),filters:i(9),partials:{},transitions:{},components:{}};var o=n.prototype;Object.defineProperty(o,"$data",{get:function(){return this._data},set:function(t){this._setData(t)}}),s(o,i(10)),s(o,i(11)),s(o,i(12)),s(o,i(13)),s(o,i(3)),s(o,i(4)),s(o,i(5)),s(o,i(6)),s(o,i(7)),t.exports=r.Vue=n},function(t,e,i){var n=i(14),r=n.extend;r(e,n),r(e,i(15)),r(e,i(16)),r(e,i(17)),r(e,i(18))},function(t,e,i){function n(t){return new Function("return function "+s.camelize(t,!0)+" (options) { this._init(options) }")()}function r(t){c.forEach(function(e){t[e]=function(t,i){return i?void(this.options[e+"s"][t]=i):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=i(1),o=i(19);e.util=s,e.nextTick=s.nextTick,e.config=i(20),e.cid=0;var a=1;e.extend=function(t){t=t||{};var e=this,i=n(t.name||"VueComponent");return i.prototype=Object.create(e.prototype),i.prototype.constructor=i,i.cid=a++,i.options=o(e.options,t),i["super"]=e,i.extend=e.extend,r(i),i},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,i){var n=i(1),r=i(21),s=i(41),o=i(42),a=i(43),c=i(44),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 i=c.parse(t,!0);i&&i.set&&i.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,i,n){var s=this,o=i?t+"**deep**":t,a=s._userWatchers[o],c=function(t,i){e.call(s,t,i)};return a?a.addCb(c):a=s._userWatchers[o]=new r(s,t,c,null,!1,i),n&&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?n.applyFilters(this.$get(e.expression),n.resolveFilters(this,e.filters).read,this):this.$get(e.expression)}return this.$get(t)},e.$interpolate=function(t){var e=o.parse(t),i=this;return e?1===e.length?i.$eval(e[0].value):e.map(function(t){return t.tag?i.$eval(t.value):t.value}).join(""):t},e.$log=function(t){var e=t?s.get(this,t):this._data;console.log(JSON.parse(JSON.stringify(e)))}},function(t,e,i){function n(t,e,i,n,s){var o=!n&&!t._isAttached&&!h.inDoc(t.$el);t._isBlock?r(t,e,i,s):i(t.$el,e,t,s),o&&t._callHook("attached")}function r(t,e,i,n){for(var r,s=t._blockStart,o=t._blockEnd;r!==o;)r=s.nextSibling,i(s,e,t),s=r;i(o,e,t,n)}function s(t){return"string"==typeof t?document.querySelector(t):t}function o(t,e,i,n){e.appendChild(t),n&&n()}function a(t,e,i,n){h.before(t,e),n&&n()}function c(t,e,i){h.remove(t),i&&i()}var h=i(1),l=i(45);e.$appendTo=function(t,e,i){t=s(t);var r=!h.inDoc(t),a=i===!1||r?o:l.append;return n(this,t,a,r,e),this},e.$prependTo=function(t,e,i){return t=s(t),t.hasChildNodes()?this.$before(t.firstChild,e,i):this.$appendTo(t,e,i),this},e.$before=function(t,e,i){t=s(t);var r=!h.inDoc(t),o=i===!1||r?a:l.before;return n(this,t,o,r,e),this},e.$after=function(t,e,i){return t=s(t),t.nextSibling?this.$before(t.nextSibling,e,i):this.$appendTo(t.parentNode,e,i),this},e.$remove=function(t,e){var i=this._isAttached&&h.inDoc(this.$el);i||(e=!1);var n,s=this,a=function(){i&&s._callHook("detached"),t&&t()};return this._isBlock&&!this._blockFragment.hasChildNodes()?(n=e===!1?o:l.removeThenAppend,r(this,this._blockFragment,n,a)):(n=e===!1?c:l.remove)(this.$el,this,a),this}},function(t,e,i){function n(t,e,i){var n=t.$parent;if(n&&i&&!s.test(e))for(;n;)n._eventsCount[e]=(n._eventsCount[e]||0)+i,n=n.$parent}var r=i(1);e.$on=function(t,e){return(this._events[t]||(this._events[t]=[])).push(e),n(this,t,1),this},e.$once=function(t,e){function i(){n.$off(t,i),e.apply(this,arguments)}var n=this;return i.fn=e,this.$on(t,i),this},e.$off=function(t,e){var i;if(!arguments.length){if(this.$parent)for(t in this._events)i=this._events[t],i&&n(this,t,-i.length);return this._events={},this}if(i=this._events[t],!i)return this;if(1===arguments.length)return n(this,t,-i.length),this._events[t]=null,this;for(var r,s=i.length;s--;)if(r=i[s],r===e||r.fn===e){n(this,t,-1),i.splice(s,1);break}return this},e.$emit=function(t){this._eventCancelled=!1;var e=this._events[t];if(e){for(var i=arguments.length-1,n=new Array(i);i--;)n[i]=arguments[i+1];i=0,e=e.length>1?r.toArray(e):e;for(var s=e.length;s>i;i++)e[i].apply(this,n)===!1&&(this._eventCancelled=!0)}return this},e.$broadcast=function(t){if(this._eventsCount[t]){var e=this._children;if(e)for(var i=0,n=e.length;n>i;i++){var r=e[i];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,i){var n=i(1);e.$addChild=function(t,e){e=e||n.Vue,t=t||{};var i,r=this,s=void 0!==t.inherit?t.inherit:e.options.inherit;if(s){var o=r._childCtors;if(o||(o=r._childCtors={}),i=o[e.cid],!i){var a=e.options.name,c=a?n.camelize(a,!0):"VueComponent";i=new Function("return function "+c+" (options) {this.constructor = "+c+";this._init(options) }")(),i.options=e.options,i.prototype=this,o[e.cid]=i}}else i=e;t._parent=r,t._root=r.$root;var h=new i(t);return this._children||(this._children=[]),this._children.push(h),h}},function(t,e,i){function n(){this._isAttached=!0,this._isReady=!0,this._callHook("ready")}function r(t){t._data.__ob__.removeVm(t),t._data=t._watchers=t._userWatchers=t._watcherList=t.$el=t.$parent=t.$root=t._children=t._bindings=t._directives=null,t._isDestroyed=!0,t._callHook("destroyed"),t.$off()}var s=i(1),o=i(46);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"),s.inDoc(this.$el)?(this._callHook("attached"),this._initDOMHooks(),n.call(this)):(this._initDOMHooks(),this.$once("hook:attached",n)),this}},e.$destroy=function(t){if(!this._isBeingDestroyed){this._callHook("beforeDestroy"),this._isBeingDestroyed=!0;var e,i=this.$parent;if(i&&!i._isBeingDestroyed&&(e=i._children.indexOf(this),i._children.splice(e,1)),this._children)for(e=this._children.length;e--;)this._children[e].$destroy();for(e=this._directives.length;e--;)this._directives[e]._teardown();for(e in this._userWatchers)this._userWatchers[e].teardown();this.$el&&(this.$el.__vue__=null);var n=this;t&&this.$el?this.$remove(function(){r(n)}):r(n)}},e.$compile=function(t){return o(t,this.$options,!0)(this,t)}},function(t,e,i){e.text=i(22),e.html=i(23),e.attr=i(24),e.show=i(25),e["class"]=i(26),e.el=i(27),e.ref=i(28),e.cloak=i(29),e.style=i(30),e.partial=i(31),e.transition=i(32),e.on=i(33),e.model=i(48),e.component=i(34),e.repeat=i(35),e["if"]=i(36),e["with"]=i(37)},function(t,e,i){var n=i(1);e.json=function(t,e){return JSON.stringify(t,null,Number(e)||2)},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),!t&&0!==t)return"";e=e||"$";var i=Math.floor(Math.abs(t)).toString(),n=i.length%3,s=n>0?i.slice(0,n)+(i.length>3?",":""):"",o="."+t.toFixed(2).slice(-2);return(0>t?"-":"")+e+s+i.slice(n).replace(r,"$1,")+o},e.pluralize=function(t){var e=n.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 i=s[e];return i||(i=parseInt(e,10)),function(e){return e.keyCode===i?t.call(this,e):void 0}}},n.extend(e,i(38))},function(t,e,i){var n=i(19);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._children=this._childCtors=null,t=this.$options=n(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,i){function n(t,e,i){if(i){var n,s,o,c;for(s in i)if(n=i[s],a.isArray(n))for(o=0,c=n.length;c>o;o++)r(t,e,s,n[o]);else r(t,e,s,n)}}function r(t,e,i,n){var r=typeof n;if("function"===r)t[e](i,n);else if("string"===r){var s=t.$options.methods,o=s&&s[n];o&&t[e](i,o)}}function s(){this._isAttached=!0;var t=this._children;if(t)for(var e=0,i=t.length;i>e;e++){var n=t[e];!n._isAttached&&c(n.$el)&&n._callHook("attached")}}function o(){this._isAttached=!1;var t=this._children;if(t)for(var e=0,i=t.length;i>e;e++){var n=t[e];n._isAttached&&!c(n.$el)&&n._callHook("detached")}}var a=i(1),c=a.inDoc;e._initEvents=function(){var t=this.$options;n(this,"$on",t.events),n(this,"$watch",t.watch)},e._initDOMHooks=function(){this.$on("hook:attached",s),this.$on("hook:detached",o)},e._callHook=function(t){var e=this.$options[t];if(e)for(var i=0,n=e.length;n>i;i++)e[i].call(this);this.$emit("hook:"+t)}},function(t,e,i){function n(){}var r=i(1),s=i(49),o=i(39);e._initScope=function(){this._initData(),this._initComputed(),this._initMethods(),this._initMeta()},e._initData=function(){for(var t,e=this._data,i=Object.keys(e),n=i.length;n--;)t=i[n],r.isReserved(t)||this._proxy(t);s.create(e).addVm(this)},e._setData=function(t){t=t||{};var e=this._data;this._data=t;var i,n,o;for(i=Object.keys(e),o=i.length;o--;)n=i[o],r.isReserved(n)||n in t||this._unproxy(n);for(i=Object.keys(t),o=i.length;o--;)n=i[o],this.hasOwnProperty(n)||r.isReserved(n)||this._proxy(n);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(i){e._data[t]=i}})},e._unproxy=function(t){delete this[t]},e._digest=function(){for(var t=this._watcherList.length;t--;)this._watcherList[t].update();var e,i=this._children;if(i)for(t=i.length;t--;)e=i[t],e.$options.inherit&&e._digest()},e._initComputed=function(){var t=this.$options.computed;if(t)for(var e in t){var i=t[e],s={enumerable:!0,configurable:!0};"function"==typeof i?(s.get=r.bind(i,this),s.set=n):(s.get=i.get?r.bind(i.get,this):n,s.set=i.set?r.bind(i.set,this):n),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 i=new o;Object.defineProperty(this,t,{enumerable:!0,configurable:!0,get:function(){return s.target&&s.target.addDep(i),e},set:function(t){t!==e&&(e=t,i.notify())}})}},function(t,e,i){var n=i(1),r=i(40),s=i(46),o=i(47);e._compile=function(t){var e=this.$options;if(e._linker)this._initElement(t),e._linker(this,t);else{var i=t;t=o(t,e),this._initElement(t);var r=s(t,e);r(this,t),e.replace&&n.replace(i,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,i,n,s){this._directives.push(new r(t,e,this,i,n,s))}},function(t,e){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),i=t.charCodeAt(t.length-1);return e!==i||34!==e&&39!==e?!1:t.slice(1,-1)};var i=/[-_](\w)/g,n=/(?:^|[-_])(\w)/g;e.camelize=function(t,e){var r=e?n:i;return t.replace(r,function(t,e){return e?e.toUpperCase():""})},e.bind=function(t,e){return function(){return t.apply(e,arguments)}},e.toArray=function(t,e){e=e||0;for(var i=t.length-e,n=new Array(i);i--;)n[i]=t[i+e];return n},e.extend=function(t,e){for(var i in e)t[i]=e[i]},e.isObject=function(t){return t&&"object"==typeof t};var r=Object.prototype.toString;e.isPlainObject=function(t){return"[object Object]"===r.call(t)},e.isArray=function(t){return Array.isArray(t)},e.define=function(t,e,i,n){Object.defineProperty(t,e,{value:i,enumerable:!!n,writable:!0,configurable:!0})}},function(t,e){e.hasProto="__proto__"in{};var i=Object.prototype.toString,n=e.inBrowser="undefined"!=typeof window&&"[object Object]"!==i.call(window),r=n?window.requestAnimationFrame||window.webkitRequestAnimationFrame||setTimeout:setTimeout;if(e.nextTick=function(t,e){e?r(function(){t.call(e)},0):r(t,0)},e.isIE9=n&&navigator.userAgent.indexOf("MSIE 9.0")>0,n&&!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,i){var n=i(20),r="undefined"!=typeof document&&document.documentElement;e.inDoc=function(t){return r&&r.contains(t)},e.attr=function(t,e){e=n.prefix+e;var i=t.getAttribute(e);return null!==i&&t.removeAttribute(e),i},e.before=function(t,e){e.parentNode.insertBefore(t,e)},e.after=function(t,i){i.nextSibling?e.before(t,i.nextSibling):i.parentNode.appendChild(t)},e.remove=function(t){t.parentNode.removeChild(t)},e.prepend=function(t,i){i.firstChild?e.before(t,i.firstChild):i.appendChild(t)},e.replace=function(t,e){var i=t.parentNode;i&&i.replaceChild(e,t)},e.copyAttributes=function(t,e){if(t.hasAttributes())for(var i=t.attributes,n=0,r=i.length;r>n;n++){var s=i[n];e.setAttribute(s.name,s.value)}},e.on=function(t,e,i){t.addEventListener(e,i)},e.off=function(t,e,i){t.removeEventListener(e,i)},e.addClass=function(t,e){if(t.classList)t.classList.add(e);else{var i=" "+(t.getAttribute("class")||"")+" ";i.indexOf(" "+e+" ")<0&&t.setAttribute("class",(i+e).trim())}},e.removeClass=function(t,e){if(t.classList)t.classList.remove(e);else{for(var i=" "+(t.getAttribute("class")||"")+" ",n=" "+e+" ";i.indexOf(n)>=0;)i=i.replace(n," ");t.setAttribute("class",i.trim())}}},function(t,e,i){i(18);e.resolveFilters=function(t,e,i){if(e){var n=i||{};return e.forEach(function(e){var i=t.$options.filters[e.name];if(i){var r,s,o=e.args;"function"==typeof i?r=i:(r=i.read,s=i.write),r&&(n.read||(n.read=[]),n.read.push(function(e){return o?r.apply(t,[e].concat(o)):r.call(t,e)})),s&&(n.write||(n.write=[]),n.write.push(function(e,i){return o?s.apply(t,[e,i].concat(o)):s.call(t,e,i)}))}}),n}},e.applyFilters=function(t,e,i,n){if(!e)return t;for(var r=0,s=e.length;s>r;r++)t=e[r].call(i,t,n);return t}},function(t,e,i){i(20)},function(t,e,i){function n(t){if(t){var e;for(var i in t)e=t[i],r.isPlainObject(e)&&(e.name=i,t[i]=r.Vue.extend(e))}}var r=i(1),s=r.extend,o=Object.create(null);o.data=function(t,e,i){if(!i){if(e&&"function"!=typeof e)return;return e||t}var n="function"==typeof e?e.call(i):e,r="function"==typeof t?t.call(i):void 0;if(n){for(var s in r)n.hasOwnProperty(s)||n.$add(s,r[s]);return n}return r},o.el=function(t,e,i){if(i||!e||"function"==typeof e){var n=e||t;return i&&"function"==typeof n?n.call(i):n}},o.created=o.ready=o.attached=o.detached=o.beforeCompile=o.compiled=o.beforeDestroy=o.destroyed=o.paramAttributes=function(t,e){return e?t?t.concat(e):r.isArray(e)?e:[e]:t},o.directives=o.filters=o.partials=o.transitions=o.components=function(t,e,i,n){var o=Object.create(i&&i.$parent?i.$parent.$options[n]:r.Vue.options[n]);if(t)for(var a,c=Object.keys(t),h=c.length;h--;)a=c[h],o[a]=t[a];return e&&s(o,e),o},o.watch=o.events=function(t,e){if(!e)return t;if(!t)return e;var i={};s(i,t);for(var n in e){var r=i[n],o=e[n];i[n]=r?r.concat(o):[o]}return i},o.methods=o.computed=function(t,e){if(!e)return t;if(!t)return e;var i=Object.create(t);return s(i,e),i};var a=function(t,e){return void 0===e?t:e};t.exports=function(t,e,i){function r(t,e,n){var r=o[n]||a;c[n]=r(t,e,i,n)}n(e.components);var s,c={};for(s in t)r(t[s],e[s],s);for(s in e)t.hasOwnProperty(s)||r(t[s],e[s],s);var h=e.mixins;if(h)for(var l=0,u=h.length;u>l;l++)for(s in h[l])r(c[s],h[l][s],s);return c}},function(t){t.exports={prefix:"v-",debug:!1,silent:!1,proto:!0,interpolate:!0,async:!0,_delimitersChanged:!0};var e=["{{","}}"];Object.defineProperty(t.exports,"delimiters",{get:function(){return e},set:function(t){e=t,this._delimitersChanged=!0}})},function(t,e,i){function n(t,e,i,n,r,s){this.vm=t,t._watcherList.push(this),this.expression=e,this.cbs=[i],this.id=++l,this.active=!0,this.deep=s,this.deps=Object.create(null),this.readFilters=n&&n.read,this.writeFilters=n&&n.write;var o=a.parse(e,r);this.getter=o.get,this.setter=o.set,this.value=this.get()}var r=i(1),s=i(20),o=i(49),a=i(44),c=i(50),h=new c,l=0,u=n.prototype;u.addDep=function(t){var e=t.id;this.newDeps[e]||(this.newDeps[e]=t,this.deps[e]||(this.deps[e]=t,t.addSub(this)))},u.get=function(){this.beforeGet();var t,e=this.vm;try{t=this.getter.call(e,e)}catch(i){}return this.deep&&JSON.stringify(t),t=r.applyFilters(t,this.readFilters,e),this.afterGet(),t},u.set=function(t){var e=this.vm;t=r.applyFilters(t,this.writeFilters,e,this.value);try{this.setter.call(e,e,t)}catch(i){}},u.beforeGet=function(){o.target=this,this.newDeps={}},u.afterGet=function(){o.target=null;for(var t in this.deps)this.newDeps[t]||this.deps[t].removeSub(this);this.deps=this.newDeps},u.update=function(){s.async?h.push(this):this.run()},u.run=function(){if(this.active){var t=this.get();if("object"==typeof t&&null!==t||t!==this.value){var e=this.value;this.value=t;for(var i=this.cbs,n=0,r=i.length;r>n;n++){i[n](t,e);var s=r-i.length;s&&(n-=s,r-=s)}}}},u.addCb=function(t){this.cbs.push(t)},u.removeCb=function(t){var e=this.cbs;if(e.length>1){var i=e.indexOf(t);i>-1&&e.splice(i,1)}else t===e[0]&&this.teardown()},u.teardown=function(){if(this.active){if(!this.vm._isBeingDestroyed){var t=this.vm._watcherList;t.splice(t.indexOf(this))}for(var e in this.deps)this.deps[e].removeSub(this);this.active=!1,this.vm=this.cbs=this.value=null}},t.exports=n},function(t,e,i){var n=i(1);t.exports={bind:function(){this.attr=3===this.el.nodeType?"nodeValue":"textContent"},update:function(t){this.el[this.attr]=n.toString(t)}}},function(t,e,i){var n=i(1),r=i(51);t.exports={bind:function(){8===this.el.nodeType&&(this.nodes=[])},update:function(t){t=n.toString(t),this.nodes?this.swap(t):this.el.innerHTML=t},swap:function(t){for(var e=this.nodes.length;e--;)n.remove(this.nodes[e]);var i=r.parse(t,!0);this.nodes=n.toArray(i.childNodes),n.before(i,this.el)}}},function(t){function e(t){t||0===t?this.el.setAttribute(this.arg,t):this.el.removeAttribute(this.arg)}function i(t){null!=t?this.el.setAttributeNS(n,this.arg,t):this.el.removeAttributeNS(n,"href")}var n="http://www.w3.org/1999/xlink",r=/^xlink:/;t.exports={priority:850,bind:function(){var t=this.arg;this.update=r.test(t)?i:e}}},function(t,e,i){var n=i(45);t.exports=function(t){var e=this.el;n.apply(e,t?1:-1,function(){e.style.display=t?"":"none"},this.vm)}},function(t,e,i){var n=i(1),r=n.addClass,s=n.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){t.exports={isLiteral:!0,bind:function(){this.vm.$$[this.expression]=this.el},unbind:function(){delete this.vm.$$[this.expression]}}},function(t,e,i){i(1);t.exports={isLiteral:!0,bind:function(){this.el===this.vm.$el&&(this.owner=this.vm.$parent,this.owner.$[this.expression]=this.vm)},unbind:function(){this.owner.$[this.expression]===this.vm&&delete this.owner.$[this.expression]}}},function(t,e,i){var n=i(20);t.exports={bind:function(){var t=this.el;this.vm.$once("hook:compiled",function(){t.removeAttribute(n.prefix+"cloak")})}}},function(t){var e=["-webkit-","-moz-","-ms-"],i=/!important;?$/;t.exports={bind:function(){var t=this.arg;t&&("$"===t.charAt(0)&&(t=t.slice(1),this.prefixed=!0),this.prop=t)},update:function(t){var n=this.prop;if(null!=t&&(t+=""),n){var r=i.test(t)?"important":"";if(r&&(t=t.replace(i,"").trim()),this.el.style.setProperty(n,t,r),this.prefixed)for(var s=e.length;s--;)this.el.style.setProperty(e[s]+n,t,r)}else this.el.style.cssText=t}}},function(t,e,i){var n=i(1),r=i(51),s=i(45);t.exports={isLiteral:!0,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?n.replace(t,this.end):t.appendChild(this.end),n.before(this.start,this.end),this._isDynamicLiteral||this.compile(this.expression)},update:function(t){this.teardown(),this.compile(t)},compile:function(t){var e=this.vm.$options.partials[t];if(e){var i=this.vm,n=r.parse(e,!0),o=i.$compile(n);this.decompile=function(){o(),s.blockRemove(this.start,this.end,i)},s.blockAppend(n,this.end,i)}},teardown:function(){this.decompile&&(this.decompile(),this.decompile=null)}}},function(t){t.exports={priority:1e3,isLiteral:!0,bind:function(){this.el.__v_trans={id:this.expression}}}},function(t,e,i){var n=i(1);t.exports={acceptStatement:!0,priority:700,bind:function(){if("IFRAME"===this.el.tagName&&"load"!==this.arg){var t=this;this.iframeBind=function(){n.on(t.el.contentWindow,t.arg,t.handler)},n.on(this.el,"load",this.iframeBind)}},update:function(t){if("function"==typeof t){this.reset();var e=this.vm;this.handler=function(i){i.targetVM=e,e.$event=i;var n=t(i);return e.$event=null,n},this.iframeBind?this.iframeBind():n.on(this.el,this.arg,this.handler)}},reset:function(){var t=this.iframeBind?this.el.contentWindow:this.el;this.handler&&n.off(t,this.arg,this.handler)},unbind:function(){this.reset(),n.off(this.el,"load",this.iframeBind)}}},function(t,e,i){var n=i(1),r=i(51);t.exports={isLiteral:!0,bind:function(){this.el.__vue__||(this.ref=document.createComment("v-component"),n.replace(this.el,this.ref),this.checkKeepAlive(),this.parentLinker=this.el._parentLinker,this._isDynamicLiteral||(this.resolveCtor(this.expression),this.build()))},checkKeepAlive:function(){this.keepAlive=this.el.hasAttribute("keep-alive"),this.keepAlive&&(this.el.removeAttribute("keep-alive"),this.cache={})},resolveCtor:function(t){this.ctorId=t,this.Ctor=this.vm.$options.components[t]},build:function(){if(this.keepAlive){var t=this.cache[this.ctorId];if(t)return this.childVM=t,void t.$before(this.ref)}var e=this.vm;if(this.Ctor&&!this.childVM){if(this.childVM=e.$addChild({el:r.clone(this.el)},this.Ctor),this.parentLinker){var i=e._directives.length,n=this.childVM.$options.inherit?this.childVM:e;this.parentLinker(n,this.childVM.$el),this.parentDirs=e._directives.slice(i)}this.keepAlive&&(this.cache[this.ctorId]=this.childVM),this.childVM.$before(this.ref)}},unbuild:function(t){var e=this.childVM;if(e){if(this.keepAlive)t&&e.$remove();else{e.$destroy(t);var i=this.parentDirs;if(i)for(var n=i.length;n--;)i[n]._teardown()}this.childVM=null}},update:function(t){this.unbuild(!0),t&&(this.resolveCtor(t),this.build())},unbind:function(){this.keepAlive=!1,this.unbuild()}}},function(t,e,i){function n(t,e){for(var i=(t._blockEnd||t.$el).nextSibling;!i.__vue__&&i!==e;)i=i.nextSibling;return i.__vue__}function r(t){if(!o.isPlainObject(t))return t;for(var e,i=Object.keys(t),n=i.length,r=new Array(n);n--;)e=i[n],r[n]={key:e,value:t[e]};return this.converted=!0,r}function s(t){for(var e=-1,i=new Array(t);++e<t;)i[e]=e;return i}var o=i(1),a=o.isObject,c=i(42),h=i(44),l=i(51),u=i(46),f=i(47),d=i(19),p=0;t.exports={bind:function(){this.id="__v_repeat_"+ ++p,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.checkTrackById(),this.checkComponent(),this.cache=Object.create(null)},checkIf:function(){null!==o.attr(this.el,"if")},checkRef:function(){var t=o.attr(this.el,"ref");this.childId=t?this.vm.$interpolate(t):null;var e=o.attr(this.el,"el");this.elId=e?this.vm.$interpolate(e):null},checkTrackById:function(){this.idKey=this.el.getAttribute("trackby"),null!==this.idKey&&this.el.removeAttribute("trackby")},checkComponent:function(){var t=o.attr(this.el,"component"),e=this.vm.$options;if(t){var i=c.parse(t);if(i){var n=c.tokensToExp(i);this.ctorGetter=h.parse(n).get}else{var r=this.Ctor=e.components[t];if(r){var s=d(r.options,{},{$parent:this.vm});this.template=f(this.template,s),this._linker=u(this.template,s)}}}else this.Ctor=o.Vue,this.inherit=!0,this.template=f(this.template),this._linker=u(this.template,e)},update:function(t){"number"==typeof t&&(t=s(t)),this.vms=this.diff(t||[],this.vms),this.childId&&(this.vm.$[this.childId]=this.vms),this.elId&&(this.vm.$$[this.elId]=this.vms.map(function(t){return t.$el}))},diff:function(t,e){var i,r,s,o,a,c=this.idKey,h=this.converted,l=this.ref,u=this.arg,f=!e,d=new Array(t.length);for(o=0,a=t.length;a>o;o++)i=t[o],r=h?i.value:i,s=!f&&this.getVm(r),s?(s._reused=!0,s.$index=o,h&&(s.$key=i.key),c&&(u?s[u]=r:s._setData(r))):(s=this.build(i,o),s._new=!0),d[o]=s,f&&s.$before(l);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--;)s=d[o],p=d[o+1],p?s._reused?(v=n(s,l),v!==p&&s.$before(p.$el,null,!1)):s.$before(p.$el):s._reused||s.$before(l),s._new=!1,s._reused=!1;return d},build:function(t,e){var i=t,n={$index:e};this.converted&&(n.$key=i.key);var r=this.converted?t.value:t,s=this.arg,o=!a(r)||s;t=o?{}:r,s?t[s]=r:o&&(n.$value=r);var c=this.Ctor||this.resolveCtor(t,n),h=this.vm.$addChild({el:l.clone(this.template),_linker:this._linker,_meta:n,data:t,inherit:this.inherit},c);return this.cacheVm(r,h),h},resolveCtor:function(t,e){var i,n=Object.create(this.vm);for(i in t)o.define(n,i,t[i]);for(i in e)o.define(n,i,e[i]);var r=this.ctorGetter.call(n,n),s=this.vm.$options.components[r];return s},unbind:function(){if(this.childId&&delete this.vm.$[this.childId],this.vms)for(var t,e=this.vms.length;e--;)t=this.vms[e],this.uncacheVm(t),t.$destroy()},cacheVm:function(t,e){var i,n=this.idKey,r=this.cache;n?(i=t[n],r[i]||(r[i]=e)):a(t)?(i=this.id,t.hasOwnProperty(i)?null===t[i]&&(t[i]=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 i=0,n=e[i];n&&(n._reused||n._new);)n=e[++i];return n}},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,i){var n=i(1),r=i(46),s=i(51),o=i(45);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"),n.replace(t,this.end),n.before(this.start,this.end),"TEMPLATE"===t.tagName?this.template=s.parse(t,!0):(this.template=document.createDocumentFragment(),this.template.appendChild(t)),this.linker=r(this.template,this.vm.$options,!0))},update:function(t){this.invalid||(t?this.insert():this.teardown())},insert:function(){if(!this.decompile){var t=this.vm,e=s.clone(this.template),i=this.linker(t,e);this.decompile=function(){i(),o.blockRemove(this.start,this.end,t)},o.blockAppend(e,this.end,t)}},teardown:function(){this.decompile&&(this.decompile(),this.decompile=null)}}},function(t,e,i){var n=(i(1),i(21));t.exports={priority:900,bind:function(){var t=this.vm;if(this.el!==t.$el);else if(t.$parent){var e=this.arg;this.watcher=new n(t.$parent,this.expression,e?function(i){t.$set(e,i)}:function(e){t.$data=e});var i=this.watcher.value;e?t.$set(e,i):t.$data=i}else;},unbind:function(){this.watcher&&this.watcher.teardown()}}},function(t,e,i){function n(t,e){if(r.isObject(t)){for(var i in t)if(n(t[i],e))return!0}else if(null!=t)return t.toString().toLowerCase().indexOf(e)>-1}var r=i(1),s=i(41);e.filterBy=function(t,e,i,o){i&&"in"!==i&&(o=i);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?n(s.get(t,o),a):n(t,a)})):t},e.orderBy=function(t,e,i){var n=r.stripQuotes(e)||this.$get(e);if(!n)return t;var o=1;return i&&("-1"===i?o=-1:33===i.charCodeAt(0)?(i=i.slice(1),o=this.$get(i)?1:-1):o=this.$get(i)?-1:1),t.slice().sort(function(t,e){return t=s.get(t,n),e=s.get(e,n),t===e?0:t>e?o:-o})}},function(t){function e(){this.id=++i,this.subs=[]}var i=0,n=e.prototype;n.addSub=function(t){this.subs.push(t)},n.removeSub=function(t){if(this.subs.length){var e=this.subs.indexOf(t);e>-1&&this.subs.splice(e,1)}},n.notify=function(){for(var t=0,e=this.subs.length;e>t;t++)this.subs[t].update()},t.exports=e},function(t,e,i){function n(t,e,i,n,s,o){this.name=t,this.el=e,this.vm=i,this.raw=n.raw,this.expression=n.expression,this.arg=n.arg,this.filters=r.resolveFilters(i,n.filters),this._linker=o,this._locked=!1,this._bound=!1,this._bind(s)}var r=i(1),s=i(20),o=i(21),a=i(42),c=i(44),h=n.prototype;h._bind=function(t){if("cloak"!==this.name&&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.update&&this._watcherExp&&(!this.isLiteral||this._isDynamicLiteral)&&!this._checkStatement()){var e=this.vm._watchers[this.raw],i=this,n=this._update=function(t,e){i._locked||i.update(t,e)};e?e.addCb(n):e=this.vm._watchers[this.raw]=new o(this.vm,this._watcherExp,n,this.filters,this.twoWay),this._watcher=e,null!=this._initValue?e.set(this._initValue):this.update(e.value)}this._bound=!0},h._checkDynamicLiteral=function(){var t=this.expression;if(t&&this.isLiteral){var e=a.parse(t);if(e){var i=a.tokensToExp(e);this.expression=this.vm.$get(i),this._watcherExp=i,this._isDynamicLiteral=!0}}},h._checkStatement=function(){var t=this.expression;if(t&&this.acceptStatement&&!c.pathTestRE.test(t)){var e=c.parse(t).get,i=this.vm,n=function(){e.call(i,i)};return this.filters&&(n=r.applyFilters(n,this.filters.read,i)),this.update(n),!0}},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 i=this;r.nextTick(function(){i._locked=!1})}},t.exports=n},function(t,e,i){function n(){}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 i,s,o,a,c,h,l,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++,i=t[d],"\\"!==i||!e()){if(a=r(i),l=u[p],c=l[a]||l["else"]||"error","error"===c)return;
+if(p=c[0],h=v[c[1]]||n,s=void 0===c[2]?i:c[2],h(),"afterPath"===p)return f}}function o(t){return l.test(t)?"."+t:+t===t>>>0?"["+t+"]":'["'+t.replace(/"/g,'\\"')+'"]'}var a=i(1),c=i(52),h=new c(1e3),l=/^[$_a-zA-Z]+[\w$]*$/,u={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="try{return o"+t.map(o).join("")+"}catch(e){};";return new Function("o",e)},e.parse=function(t){var i=h.get(t);return i||(i=s(t),i&&(i.get=e.compileGetter(i),h.put(t,i))),i},e.get=function(t,i){return i=e.parse(i),i?i.get(t):void 0},e.set=function(t,i,n){if("string"==typeof i&&(i=e.parse(i)),!i||!a.isObject(t))return!1;for(var r,s,o=0,c=i.length-1;c>o;o++)r=t,s=i[o],t=t[s],a.isObject(t)||(t={},r.$add(s,t));return s=i[o],s in t?t[s]=n:t.$add(s,n),!0}},function(t,e,i){function n(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 i=n(l),r=n(u),s=n(t),o=n(e);c=new RegExp(i+"?"+s+"(.+?)"+o+r+"?","g"),h=new RegExp("^"+i+s+".*"+o+r+"$"),a=new f(1e3)}function s(t,e,i){return t.tag?e&&t.oneTime?'"'+e.$eval(t.value)+'"':i?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 i=0,n=e.filters.length;n>i;i++){var r=e.filters[i],s=r.args?',"'+r.args.join('","')+'"':"";t='this.$options.filters["'+r.name+'"].apply(this,['+t+s+"])"}return t}return"("+t+")"}return"("+t+")"}var a,c,h,l,u,f=i(52),d=i(20),p=i(43),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 i,n,s,o,l,u,f=[],p=c.lastIndex=0;i=c.exec(t);)n=i.index,n>p&&f.push({value:t.slice(p,n)}),o=i[1].charCodeAt(0),l=42===o,u=62===o,s=l||u?i[1].slice(1):i[1],f.push({tag:!0,value:s.trim(),html:h.test(i[0]),oneTime:l,partial:u}),p=n+i[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,i){function n(){_.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 i=e.match(k);t.name=i[0],t.args=i.length>1?i.slice(1):null}t&&(_.filters=_.filters||[]).push(t),b=a+1}var s,o,a,c,h,l,u,f,d,p,v,m,_,b,g,y=i(1),w=i(52),$=new w(1e3),x=/^[^\{\?]+$|^'[^']*'$|^"[^"]*"$/,k=/[^\s'"]+|'[^']+'|"[^"]+"/g;e.parse=function(t){var e=$.get(t);if(e)return e;for(s=t,h=l=!1,u=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(l)34===o&&(l=!l);else if(44!==o||d||u||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:l=!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:u++;break;case 125:u--}else g=s.slice(p,a).trim(),x.test(g)&&(v=a+1,_.arg=y.stripQuotes(g)||g);else n(),_={},p=v=b=a+1;return(0===a||p!==a)&&n(),$.put(t,m),m}},function(t,e,i){function n(t){var e=$.length;return $[e]=t.replace(m,"\\n"),'"'+e+'"'}function r(t){var e=t.charAt(0),i=t.slice(1);return w.test(i)?t:(i=i.indexOf('"')>-1?i.replace(b,s):i,e+"scope."+i)}function s(t,e){return $[e]}function o(t,e){$.length=0;var i=t.replace(_,n).replace(v,"");i=(" "+i).replace(y,r).replace(b,s);var o=c(i);return o?{get:o,body:i,set:e?h(i):null}:void 0}function a(t){var e,i;return t.indexOf("[")<0?(i=t.split("."),e=u.compileGetter(i)):(i=u.parse(t),e=i.get),{get:e,set:function(t,e){u.set(t,i,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 l(t){t.set||(t.set=h(t.body))}var u=(i(1),i(41)),f=i(52),d=new f(1e3),p="Math,break,case,catch,continue,debugger,default,delete,do,else,false,finally,for,function,if,in,instanceof,new,null,return,switch,this,throw,true,try,typeof,var,void,while,with,undefined,abstract,boolean,byte,char,class,const,double,enum,export,extends,final,float,goto,implements,import,int,interface,long,native,package,private,protected,public,short,static,super,synchronized,throws,transient,volatile,arguments,let,yield",v=/\s/g,m=/\n/g,_=/[\{,]\s*[\w\$_]+\s*:|'[^']*'|"[^"]*"/g,b=/"(\d+)"/g,g=/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*$/,y=/[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g,w=new RegExp("^("+p.replace(/,/g,"\\b|")+"\\b)"),$=[];e.parse=function(t,e){t=t.trim();var i=d.get(t);if(i)return e&&l(i),i;var n=g.test(t)?a(t):o(t,e);return d.put(t,n),n},e.pathTestRE=g},function(t,e,i){var n=i(1),r=i(53),s=i(54);e.append=function(t,e,i,n){o(t,1,function(){e.appendChild(t)},i,n)},e.before=function(t,e,i,r){o(t,1,function(){n.before(t,e)},i,r)},e.remove=function(t,e,i){o(t,-1,function(){n.remove(t)},e,i)},e.removeThenAppend=function(t,e,i,n){o(t,-1,function(){e.appendChild(t)},i,n)},e.blockAppend=function(t,i,r){for(var s=n.toArray(t.childNodes),o=0,a=s.length;a>o;o++)e.before(s[o],i,r)},e.blockRemove=function(t,i,n){for(var r,s=t.nextSibling;s!==i;)r=s.nextSibling,e.remove(s,n),s=r};var o=e.apply=function(t,e,i,o,a){var c=t.__v_trans;if(!c||!o._isCompiled||o.$parent&&!o.$parent._isCompiled)return i(),void(a&&a());var h=o.$options.transitions[c.id];h?s(t,e,i,c,h,o,a):n.transitionEndEvent?r(t,e,i,c,a):(i(),a&&a())}},function(t,e,i){function n(t,e){var i=t.nodeType;return 1===i&&"SCRIPT"!==t.tagName?r(t,e):3===i&&g.interpolate?o(t,e):void 0}function r(t,e){var i,n,r;if(t.__vue__||(n=t.tagName.toLowerCase(),r=n.indexOf("-")>0&&e.components[n],r&&t.setAttribute(g.prefix+"component",n)),(r||t.hasAttributes())&&(i=d(t,e),!i)){var o=v(t,e);i=o.length?s(o):null}if("TEXTAREA"===t.tagName){var a=i;i=function(t,e){e.value=t.$interpolate(e.value),a&&a(t,e)},i.terminal=!0}return i}function s(t){return function(e,i){for(var n,r,s,o=t.length;o--;)if(n=t[o],n._link)n._link(e,i);else for(s=n.descriptors.length,r=0;s>r;r++)e._bindDir(n.name,i,n.descriptors[r],n.def)}}function o(t,e){var i=y.parse(t.nodeValue);if(!i)return null;for(var n,r,s,o=document.createDocumentFragment(),c=e.directives,h=0,l=i.length;l>h;h++)r=i[h],s=r.value,r.tag?r.oneTime?n=document.createTextNode(s):r.html?(n=document.createComment("v-html"),r.type="html",r.def=c.html,r.descriptor=w.parse(s)[0]):r.partial?(n=document.createComment("v-partial"),r.type="partial",r.def=c.partial,r.descriptor=w.parse(s)[0]):(n=document.createTextNode(" "),r.type="text",r.def=c.text,r.descriptor=w.parse(s)[0]):n=document.createTextNode(s),o.appendChild(n);return a(i,o,e)}function a(t,e){return function(i,n){for(var r,s,o,a=e.cloneNode(!0),c=b.toArray(a.childNodes),h=0,l=t.length;l>h;h++)r=t[h],s=r.value,r.tag&&(o=c[h],r.oneTime?(s=i.$eval(s),r.html?b.replace(o,$.parse(s,!0)):o.nodeValue=s):i._bindDir(r.type,o,r.descriptor,r.def));b.replace(n,a)}}function c(t,e){for(var i,r,s,o=[],a=0,l=t.length;l>a;a++)s=t[a],i=n(s,e),r=i&&i.terminal||!s.hasChildNodes()?null:c(s.childNodes,e),o.push(i,r);return o.length?h(o):null}function h(t){return function(e,i){i=b.toArray(i);for(var n,r,s,o=0,a=0,c=t.length;c>o;a++)n=i[a],r=t[o++],s=t[o++],r&&r(e,n),s&&s(e,n.childNodes)}}function l(t,e,i){for(var n,r,s,o=[],a=e.length;a--;)if(n=e[a],r=t.getAttribute(n),null!==r){s={name:n,value:r};var c=y.parse(r);if(c){if(t.removeAttribute(n),c.length>1)continue;s.dynamic=!0,s.value=c[0].value}o.push(s)}return u(o,i)}function u(t,e){var i=e.directives["with"];return function(e,n){for(var r,s,o=t.length;o--;)r=t[o],s=b.camelize(r.name.replace(x,"")),r.dynamic?e._bindDir("with",n,{arg:s,expression:r.value},i):e.$set(s,r.value)}}function f(){}function d(t,e){if(null!==b.attr(t,"pre"))return f;for(var i,n,r=0;3>r;r++)if(n=k[r],i=b.attr(t,n))return p(t,n,i,e)}function p(t,e,i,n){var r=w.parse(i)[0],o=n.directives[e];if("component"===e){var a=v(t,n,!0);t._parentLinker=a.length?s(a):null}var c=function(t,i){t._bindDir(e,i,r,o)};return c.terminal=!0,c}function v(t,e,i){for(var n,r,s,o,a,c=b.toArray(t.attributes),h=c.length,l=[];h--;)if(n=c[h],r=n.name,0===r.indexOf(g.prefix)){if(o=r.slice(g.prefix.length),i&&("with"===o||"ref"===o))continue;a=e.directives[o],a&&l.push({name:o,descriptors:w.parse(n.value),def:a})}else g.interpolate&&(s=m(t,r,n.value,e),s&&l.push(s));return l.sort(_),l}function m(t,e,i,n){var r=y.parse(i);if(r){for(var s=n.directives.attr,o=r.length,a=!0;o--;){var c=r[o];c.tag&&!c.oneTime&&(a=!1)}return{def:s,_link:a?function(t,n){n.setAttribute(e,t.$interpolate(i))}:function(t,i){var n=y.tokensToExp(r,t),o=w.parse(e+":"+n)[0];t._bindDir("attr",i,o,s)}}}}function _(t,e){return t=t.def.priority||0,e=e.def.priority||0,t>e?1:-1}var b=i(1),g=i(20),y=i(42),w=i(43),$=i(51);t.exports=function(t,e,i){var r=!i&&e.paramAttributes,s=r?l(t,r,e):null,o=t instanceof DocumentFragment?null:n(t,e),a=o&&o.terminal||!t.hasChildNodes()?null:c(t.childNodes,e);return function(t,e){var n=t._directives.length;if(s&&s(t,e),o&&o(t,e),a&&a(t,e.childNodes),i){var r=t._directives.slice(n);return function(){for(var e=r.length;e--;)r[e]._teardown();e=t._directives.indexOf(r[0]),t._directives.splice(e,r.length)}}}};var x=/^data-/,k=["repeat","if","component"];f.terminal=!0},function(t,e,i){function n(t,e){var i=e.template,n=h.parse(i,!0);if(n){if(r(t),e.replace){if(n.childNodes.length>1)return s(n),n;var o=n.firstChild;return c.copyAttributes(t,o),s(o),o}return t.appendChild(n),s(t),t}}function r(t){var e;if(l=null,t.hasChildNodes())for(l=document.createElement("div");e=t.firstChild;)l.appendChild(e)}function s(t){var e=o(t),i=e.length;if(i){for(var n,r,s,h,u;i--;)n=e[i],l?(r=n.getAttribute("select"),r?(s=l.querySelectorAll(r),n.content=c.toArray(s.length?s:n.childNodes)):u=n):n.content=c.toArray(n.childNodes);for(i=0,h=e.length;h>i;i++)n=e[i],n!==u&&a(n,n.content);u&&a(u,c.toArray(l.childNodes))}}function o(t){return c.isArray(t)?u.apply([],t.map(o)):t.querySelectorAll?c.toArray(t.querySelectorAll("content")):[]}function a(t,e){for(var i=t.parentNode,n=0,r=e.length;r>n;n++)i.insertBefore(e[n],t);i.removeChild(t)}var c=i(1),h=i(51);t.exports=function(t,e){return"TEMPLATE"===t.tagName&&(t=h.parse(t)),e&&e.template&&(t=n(t,e)),t instanceof DocumentFragment&&(c.prepend(document.createComment("v-start"),t),t.appendChild(document.createComment("v-end"))),t};var l,u=[].concat},function(t,e,i){var n=(i(1),{_default:i(55),radio:i(56),select:i(57),checkbox:i(58)});t.exports={priority:800,twoWay:!0,handlers:n,bind:function(){var t=this.filters;t&&t.read&&!t.write;var e,i=this.el,r=i.tagName;if("INPUT"===r)e=n[i.type]||n._default;else if("SELECT"===r)e=n.select;else{if("TEXTAREA"!==r)return;e=n._default}e.bind.call(this),this.update=e.update,this.unbind=e.unbind}}},function(t,e,i){function n(t,e){t.__proto__=e}function r(t,e,i){for(var n,r=i.length;r--;)n=i[r],o.define(t,n,e[n])}function s(t,e){if(this.id=++u,this.value=t,this.active=!0,this.bindings=[],o.define(t,"__ob__",this),e===f){var i=a.proto&&o.hasProto?n:r;i(t,h,l),this.observeArray(t)}else e===d&&this.walk(t)}var o=i(1),a=i(20),c=i(39),h=i(59),l=Object.getOwnPropertyNames(h);i(60);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,i,n=Object.keys(t),r=n.length;r--;)e=n[r],i=e.charCodeAt(0),36!==i&&95!==i&&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 i=this,n=i.observe(e),r=new c;n&&n.bindings.push(r),Object.defineProperty(i.value,t,{enumerable:!0,configurable:!0,get:function(){return i.active&&s.target&&s.target.addDep(r),e},set:function(t){if(t!==e){var n=e&&e.__ob__;if(n){var s=n.bindings;s.splice(s.indexOf(r),1)}e=t;var o=i.observe(t);o&&o.bindings.push(r),r.notify()}}})},p.notify=function(){for(var t=this.bindings,e=0,i=t.length;i>e;e++)t[e].notify()},p.addVm=function(t){(this.vms=this.vms||[]).push(t)},p.removeVm=function(t){this.vms.splice(this.vms.indexOf(t),1)},t.exports=s},function(t,e,i){function n(){this.reset()}var r=i(1),s=n.prototype;s.push=function(t){t.id&&this.has[t.id]&&!this.flushing||(this.queue.push(t),this.has[t.id]=t,this.waiting||(this.waiting=!0,r.nextTick(this.flush,this)))},s.flush=function(){this.flushing=!0;for(var t=0;t<this.queue.length;t++){var e=this.queue[t];e.cancelled||e.run()}this.reset()},s.reset=function(){this.has={},this.queue=[],this.waiting=!1,this.flushing=!1},t.exports=n},function(t,e,i){function n(t){var e=a.get(t);if(e)return e;var i=document.createDocumentFragment(),n=l.exec(t);if(n){var r=n[1],s=h[r]||h._default,o=s[0],c=s[1],u=s[2],f=document.createElement("div");for(f.innerHTML=c+t.trim()+u;o--;)f=f.lastChild;for(var d;d=f.firstChild;)i.appendChild(d)}else i.appendChild(document.createTextNode(t));return a.put(t,i),i}function r(t){var e=t.tagName;return"TEMPLATE"===e&&t.content instanceof DocumentFragment?t.content:n("SCRIPT"===e?t.textContent:t.innerHTML)}var s=i(1),o=i(52),a=new o(100),c=s.inBrowser?function(){var t=document.createElement("div");return t.innerHTML="<template>1</template>",!t.cloneNode(!0).firstChild.innerHTML}():!1,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 l=/<([\w:]+)/;e.clone=function(t){var e=t.cloneNode(!0);if(c){var i=t.querySelectorAll("template");if(i.length)for(var n=e.querySelectorAll("template"),r=n.length;r--;)n[r].parentNode.replaceChild(i[r].cloneNode(!0),n[r])}return e},e.parse=function(t,i){var s,o;return t instanceof DocumentFragment?i?t.cloneNode(!0):t:("string"==typeof t?"#"===t.charAt(0)?(o=a.get(t),o||(s=document.getElementById(t.slice(1)),s&&(o=r(s),a.put(t,o)))):o=n(t):t.nodeType&&(o=r(t)),o&&i?e.clone(o):o)}},function(t){function e(t){this.size=0,this.limit=t,this.head=this.tail=void 0,this._keymap={}}var i=e.prototype;i.put=function(t,e){var i={key:t,value:e};return this._keymap[t]=i,this.tail?(this.tail.newer=i,i.older=this.tail):this.head=i,this.tail=i,this.size===this.limit?this.shift():void this.size++},i.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},i.get=function(t,e){var i=this._keymap[t];if(void 0!==i)return i===this.tail?e?i:i.value:(i.newer&&(i===this.head&&(this.head=i.newer),i.newer.older=i.older),i.older&&(i.older.newer=i.newer),i.newer=void 0,i.older=this.tail,this.tail&&(this.tail.newer=i),this.tail=i,e?i:i.value)},t.exports=e},function(t,e,i){function n(t,e,i,n,s){f.push({el:t,dir:e,cb:s,cls:n,op:i}),d||(d=!0,a.nextTick(r))}function r(){document.documentElement.offsetHeight;f.forEach(s),f=[],d=!1}function s(t){function e(t,e){n.event=t;var r=n.callback=function(o){o.target===i&&(a.off(i,t,r),n.event=n.callback=null,e&&e(),s&&s())};a.on(i,t,r)}var i=t.el,n=i.__v_trans,r=t.cls,s=t.cb,c=t.op,l=o(i,n,r);if(t.dir>0)1===l?(h(i,r),s&&e(a.transitionEndEvent)):2===l?e(a.animationEndEvent,function(){h(i,r)}):(h(i,r),s&&s());else if(l){var u=1===l?a.transitionEndEvent:a.animationEndEvent;e(u,function(){c(),h(i,r)})}else c(),h(i,r),s&&s()}function o(t,e,i){var n=e.cache&&e.cache[i];if(n)return n;var r=t.style,s=window.getComputedStyle(t),o=r[l]||s[l];if(o&&"0s"!==o)n=1;else{var a=r[u]||s[u];a&&"0s"!==a&&(n=2)}return n&&(e.cache||(e.cache={}),e.cache[i]=n),n}var a=i(1),c=a.addClass,h=a.removeClass,l=a.transitionProp+"Duration",u=a.animationProp+"Duration",f=[],d=!1;t.exports=function(t,e,i,r,s){var o=r.id||"v",l=o+"-enter",u=o+"-leave";r.callback&&(a.off(t,r.event,r.callback),h(t,l),h(t,u),r.event=r.callback=null),e>0?(c(t,l),i(),n(t,e,null,l,s)):(c(t,u),n(t,e,i,u,s))}},function(t){t.exports=function(t,e,i,n,r,s,o){n.cancel&&(n.cancel(),n.cancel=null),e>0?(r.beforeEnter&&r.beforeEnter.call(s,t),i(),r.enter?n.cancel=r.enter.call(s,t,function(){n.cancel=null,o&&o()}):o&&o()):r.leave?n.cancel=r.leave.call(s,t,function(){n.cancel=null,i(),o&&o()}):(i(),o&&o())}},function(t,e,i){var n=i(1);t.exports={bind:function(){function t(){e.set(s?n.toNumber(i.value):i.value,!0)}var e=this,i=this.el,r=i.hasAttribute("lazy");r&&i.removeAttribute("lazy");var s=i.hasAttribute("number")||"number"===i.type;s&&i.removeAttribute("number");var o=!1;this.cpLock=function(){o=!0},this.cpUnlock=function(){o=!1,t()},n.on(i,"compositionstart",this.cpLock),n.on(i,"compositionend",this.cpUnlock),this.listener=function(){if(!o){var r;try{r=i.value.length-i.selectionStart}catch(s){}t(),n.nextTick(function(){var t=e._watcher.value;if(e.update(t),null!=r){var s=n.toString(t).length-r;i.setSelectionRange(s,s)}})}},this.event=r?"change":"input",n.on(i,this.event,this.listener),!r&&n.isIE9&&(this.onCut=function(){n.nextTick(e.listener)},this.onDel=function(t){(46===t.keyCode||8===t.keyCode)&&e.listener()},n.on(i,"cut",this.onCut),n.on(i,"keyup",this.onDel)),(i.hasAttribute("value")||"TEXTAREA"===i.tagName&&i.value.trim())&&(this._initValue=s?n.toNumber(i.value):i.value)},update:function(t){this.el.value=n.toString(t)},unbind:function(){var t=this.el;n.off(t,this.event,this.listener),n.off(t,"compositionstart",this.cpLock),n.off(t,"compositionend",this.cpUnlock),this.onCut&&(n.off(t,"cut",this.onCut),n.off(t,"keyup",this.onDel))}}},function(t,e,i){var n=i(1);t.exports={bind:function(){var t=this,e=this.el;this.listener=function(){t.set(e.value,!0)},n.on(e,"change",this.listener),e.checked&&(this._initValue=e.value)},update:function(t){this.el.checked=t==this.el.value},unbind:function(){n.off(this.el,"change",this.listener)}}},function(t,e,i){function n(t){function e(t){l.isArray(t)&&(i.el.innerHTML="",r(i.el,t),i._watcher&&i.update(i._watcher.value))}var i=this;this.optionWatcher=new u(this.vm,t,e),e(this.optionWatcher.value)}function r(t,e){for(var i,n,s=0,o=e.length;o>s;s++)i=e[s],i.options?(n=document.createElement("optgroup"),n.label=i.label,r(n,i.options)):(n=document.createElement("option"),"string"==typeof i?n.text=n.value=i:(n.text=i.text,n.value=i.value)),t.appendChild(n)}function s(){for(var t,e=this.el.options,i=0,n=e.length;n>i;i++)e[i].hasAttribute("selected")&&(this.multiple?(t||(t=[])).push(e[i].value):t=e[i].value);t&&(this._initValue=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 i=t.length;i--;)if(t[i]==e)return i;return-1}var l=i(1),u=i(21);t.exports={bind:function(){var t=this,e=this.el,i=e.getAttribute("options");i&&(e.removeAttribute("options"),n.call(this,i)),this.multiple=e.hasAttribute("multiple"),this.listener=function(){var i=t.multiple?o(e):e.value;t.set(i,!0)},l.on(e,"change",this.listener),s.call(this)},update:function(t){var e=this.el;e.selectedIndex=-1;for(var i,n=this.multiple&&l.isArray(t),r=e.options,s=r.length;s--;)i=r[s],i.selected=n?h(t,i.value)>-1:t==i.value},unbind:function(){l.off(this.el,"change",this.listener),this.optionWatcher&&this.optionWatcher.teardown()}}},function(t,e,i){var n=i(1);t.exports={bind:function(){var t=this,e=this.el;this.listener=function(){t.set(e.checked,!0)},n.on(e,"change",this.listener),e.checked&&(this._initValue=e.checked)},update:function(t){this.el.checked=!!t},unbind:function(){n.off(this.el,"change",this.listener)}}},function(t,e,i){var n=i(1),r=Array.prototype,s=Object.create(r);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=r[t];n.define(s,t,function(){for(var i=arguments.length,n=new Array(i);i--;)n[i]=arguments[i];var r,s=e.apply(this,n),o=this.__ob__;switch(t){case"push":r=n;break;case"unshift":r=n;break;case"splice":r=n.slice(2)}return r&&o.observeArray(r),o.notify(),s})}),n.define(r,"$set",function(t,e){return t>=this.length&&(this.length=t+1),this.splice(t,1,e)[0]}),n.define(r,"$remove",function(t){return"number"!=typeof t&&(t=this.indexOf(t)),t>-1?this.splice(t,1)[0]:void 0}),t.exports=s},function(t,e,i){var n=i(1),r=Object.prototype;n.define(r,"$add",function(t,e){var i=this.__ob__;if(!i)return void(this[t]=e);if(!n.isReserved(t)&&!this.hasOwnProperty(t))if(i.convert(t,e),i.vms)for(var r=i.vms.length;r--;){var s=i.vms[r];s._proxy(t),s._digest()}else i.notify()}),n.define(r,"$delete",function(t){var e=this.__ob__;if(!e)return void delete this[t];if(!n.isReserved(t)&&this.hasOwnProperty(t))if(delete this[t],e.vms)for(var i=e.vms.length;i--;){var r=e.vms[i];r._unproxy(t),r._digest()}else e.notify()})}])});
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/api/child.js b/vendor/assets/javascripts/bower/vue/src/api/child.js
new file mode 100644
index 0000000..5449e01
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/api/child.js
@@ -0,0 +1,53 @@
+var _ = require('../util')
+
+/**
+ * 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
+ */
+
+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
+    if (!ctors) {
+      ctors = parent._childCtors = {}
+    }
+    ChildVue = ctors[BaseCtor.cid]
+    if (!ChildVue) {
+      var optionName = BaseCtor.options.name
+      var className = optionName
+        ? _.camelize(optionName, true)
+        : '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
+  }
+  opts._parent = parent
+  opts._root = parent.$root
+  var child = new ChildVue(opts)
+  if (!this._children) {
+    this._children = []
+  }
+  this._children.push(child)
+  return child
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/api/data.js b/vendor/assets/javascripts/bower/vue/src/api/data.js
new file mode 100644
index 0000000..0f9a04c
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/api/data.js
@@ -0,0 +1,158 @@
+var _ = require('../util')
+var Watcher = require('../watcher')
+var Path = require('../parse/path')
+var textParser = require('../parse/text')
+var dirParser = require('../parse/directive')
+var expParser = require('../parse/expression')
+var filterRE = /[^|]\|[^|]/
+
+/**
+ * Get the value from an expression on this vm.
+ *
+ * @param {String} exp
+ * @return {*}
+ */
+
+exports.$get = function (exp) {
+  var res = expParser.parse(exp)
+  if (res) {
+    return res.get.call(this, this)
+  }
+}
+
+/**
+ * Set the value from an expression on this vm.
+ * The expression must be a valid left-hand
+ * expression in an assignment.
+ *
+ * @param {String} exp
+ * @param {*} val
+ */
+
+exports.$set = function (exp, val) {
+  var res = expParser.parse(exp, true)
+  if (res && res.set) {
+    res.set.call(this, this, val)
+  }
+}
+
+/**
+ * Add a property on the VM
+ *
+ * @param {String} key
+ * @param {*} val
+ */
+
+exports.$add = function (key, val) {
+  this._data.$add(key, val)
+}
+
+/**
+ * Delete a property on the VM
+ *
+ * @param {String} key
+ */
+
+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 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, null, false, deep)
+  } else {
+    watcher.addCb(wrappedCb)
+  }
+  if (immediate) {
+    wrappedCb(watcher.value)
+  }
+  return function unwatchFn () {
+    watcher.removeCb(wrappedCb)
+    if (!watcher.active) {
+      vm._userWatchers[key] = null
+    }
+  }
+}
+
+/**
+ * Evaluate a text directive, including filters.
+ *
+ * @param {String} text
+ * @return {String}
+ */
+
+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)
+  } else {
+    // no filter
+    return this.$get(text)
+  }
+}
+
+/**
+ * Interpolate a piece of template text.
+ *
+ * @param {String} text
+ * @return {String}
+ */
+
+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, path)
+    : this._data
+  console.log(JSON.parse(JSON.stringify(data)))
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/api/dom.js b/vendor/assets/javascripts/bower/vue/src/api/dom.js
new file mode 100644
index 0000000..748ddb3
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/api/dom.js
@@ -0,0 +1,209 @@
+var _ = require('../util')
+var transition = require('../transition')
+
+/**
+ * Append instance to target
+ *
+ * @param {Node} target
+ * @param {Function} [cb]
+ * @param {Boolean} [withTransition] - defaults to true
+ */
+
+exports.$appendTo = function (target, cb, withTransition) {
+  target = query(target)
+  var targetIsDetached = !_.inDoc(target)
+  var op = withTransition === false || targetIsDetached
+    ? append
+    : transition.append
+  insert(this, target, op, targetIsDetached, cb)
+  return this
+}
+
+/**
+ * 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) {
+  target = query(target)
+  var targetIsDetached = !_.inDoc(target)
+  var op = withTransition === false || targetIsDetached
+    ? before
+    : transition.before
+  insert(this, target, op, targetIsDetached, cb)
+  return this
+}
+
+/**
+ * Insert instance after target
+ *
+ * @param {Node} target
+ * @param {Function} [cb]
+ * @param {Boolean} [withTransition] - defaults to true
+ */
+
+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
+}
+
+/**
+ * Remove instance from DOM
+ *
+ * @param {Function} [cb]
+ * @param {Boolean} [withTransition] - defaults to true
+ */
+
+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
+}
+
+/**
+ * Shared DOM insertion function.
+ *
+ * @param {Vue} vm
+ * @param {Element} target
+ * @param {Function} op
+ * @param {Boolean} targetIsDetached
+ * @param {Function} [cb]
+ */
+
+function insert (vm, target, op, targetIsDetached, cb) {
+  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')
+  }
+}
+
+/**
+ * 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
+ */
+
+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)
+}
+
+/**
+ * Check for selectors
+ *
+ * @param {String|Element} el
+ */
+
+function query (el) {
+  return typeof el === 'string'
+    ? document.querySelector(el)
+    : el
+}
+
+/**
+ * Append operation that takes a callback.
+ *
+ * @param {Node} el
+ * @param {Node} target
+ * @param {Vue} vm - unused
+ * @param {Function} [cb]
+ */
+
+function append (el, target, vm, cb) {
+  target.appendChild(el)
+  if (cb) cb()
+}
+
+/**
+ * InsertBefore operation that takes a callback.
+ *
+ * @param {Node} el
+ * @param {Node} target
+ * @param {Vue} vm - unused
+ * @param {Function} [cb]
+ */
+
+function before (el, target, vm, cb) {
+  _.before(el, target)
+  if (cb) cb()
+}
+
+/**
+ * Remove operation that takes a callback.
+ *
+ * @param {Node} el
+ * @param {Vue} vm - unused
+ * @param {Function} [cb]
+ */
+
+function remove (el, vm, cb) {
+  _.remove(el)
+  if (cb) cb()
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/api/events.js b/vendor/assets/javascripts/bower/vue/src/api/events.js
new file mode 100644
index 0000000..5a8b989
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/api/events.js
@@ -0,0 +1,176 @@
+var _ = require('../util')
+
+/**
+ * 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
+}
+
+/**
+ * Adds an `event` listener that will be invoked a single
+ * time then automatically removed.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ */
+
+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
+}
+
+/**
+ * Remove the given callback for `event` or all
+ * registered callbacks.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ */
+
+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)
+        }
+      }
+    }
+    this._events = {}
+    return this
+  }
+  // specific event
+  cbs = this._events[event]
+  if (!cbs) {
+    return this
+  }
+  if (arguments.length === 1) {
+    modifyListenerCount(this, event, -cbs.length)
+    this._events[event] = null
+    return this
+  }
+  // specific handler
+  var cb
+  var i = cbs.length
+  while (i--) {
+    cb = cbs[i]
+    if (cb === fn || cb.fn === fn) {
+      modifyListenerCount(this, event, -1)
+      cbs.splice(i, 1)
+      break
+    }
+  }
+  return this
+}
+
+/**
+ * Trigger an event on self.
+ *
+ * @param {String} event
+ */
+
+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
+      }
+    }
+  }
+  return this
+}
+
+/**
+ * Recursively broadcast an event to all children instances.
+ *
+ * @param {String} event
+ * @param {...*} additional arguments
+ */
+
+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
+  if (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)
+      }
+    }
+  }
+  return this
+}
+
+/**
+ * Recursively propagate an event up the parent chain.
+ *
+ * @param {String} event
+ * @param {...*} additional arguments
+ */
+
+exports.$dispatch = function () {
+  var parent = this.$parent
+  while (parent) {
+    parent.$emit.apply(parent, arguments)
+    parent = parent._eventCancelled
+      ? null
+      : parent.$parent
+  }
+  return this
+}
+
+/**
+ * Modify the listener counts on all parents.
+ * This bookkeeping allows $broadcast to return early when
+ * no child has listened to a certain event.
+ *
+ * @param {Vue} vm
+ * @param {String} event
+ * @param {Number} count
+ */
+
+var hookRE = /^hook:/
+function modifyListenerCount (vm, event, count) {
+  var parent = vm.$parent
+  // hooks do not get broadcasted so no need
+  // to do bookkeeping for them
+  if (!parent || !count || hookRE.test(event)) return
+  while (parent) {
+    parent._eventsCount[event] =
+      (parent._eventsCount[event] || 0) + count
+    parent = parent.$parent
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/api/global.js b/vendor/assets/javascripts/bower/vue/src/api/global.js
new file mode 100644
index 0000000..3bedf63
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/api/global.js
@@ -0,0 +1,133 @@
+var _ = require('../util')
+var mergeOptions = require('../util/merge-option')
+
+/**
+ * Expose useful internals
+ */
+
+exports.util       = _
+exports.nextTick   = _.nextTick
+exports.config     = require('../config')
+
+/**
+ * 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 {Object} extendOptions
+ */
+
+exports.extend = function (extendOptions) {
+  extendOptions = extendOptions || {}
+  var Super = this
+  var Sub = createClass(extendOptions.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
+}
+
+/**
+ * A function that returns a sub-class constructor with the
+ * given name. This gives us much nicer output when
+ * logging instances in the console.
+ *
+ * @param {String} name
+ * @return {Function}
+ */
+
+function createClass (name) {
+  return new Function(
+    'return function ' + _.camelize(name, true) +
+    ' (options) { this._init(options) }'
+  )()
+}
+
+/**
+ * Plugin system
+ *
+ * @param {Object} plugin
+ */
+
+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
+}
+
+/**
+ * Define asset registration methods on a constructor.
+ *
+ * @param {Function} Constructor
+ */
+
+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
+    }
+  }
+}
+
+createAssetRegisters(exports)
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/api/lifecycle.js b/vendor/assets/javascripts/bower/vue/src/api/lifecycle.js
new file mode 100644
index 0000000..bd9408f
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/api/lifecycle.js
@@ -0,0 +1,145 @@
+var _ = require('../util')
+var compile = require('../compile/compile')
+
+/**
+ * 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
+    }
+  }
+  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
+}
+
+/**
+ * Mark an instance as ready.
+ */
+
+function ready () {
+  this._isAttached = true
+  this._isReady = true
+  this._callHook('ready')
+}
+
+/**
+ * Teardown an instance, unobserves the data, unbind all the
+ * directives, turn off all the event listeners, etc.
+ *
+ * @param {Boolean} remove - whether to remove the DOM node.
+ * @public
+ */
+
+exports.$destroy = function (remove) {
+  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) {
+    i = parent._children.indexOf(this)
+    parent._children.splice(i, 1)
+  }
+  // destroy all children.
+  if (this._children) {
+    i = this._children.length
+    while (i--) {
+      this._children[i].$destroy()
+    }
+  }
+  // teardown all directives. this also tearsdown all
+  // directive-owned watchers.
+  i = this._directives.length
+  while (i--) {
+    this._directives[i]._teardown()
+  }
+  // teardown all user watchers.
+  for (i in this._userWatchers) {
+    this._userWatchers[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 () {
+      cleanup(self)
+    })
+  } else {
+    cleanup(self)
+  }
+}
+
+/**
+ * Clean up to ensure garbage collection.
+ * This is called after the leave transition if there
+ * is any.
+ *
+ * @param {Vue} vm
+ */
+
+function cleanup (vm) {
+  // remove reference from data ob
+  vm._data.__ob__.removeVm(vm)
+  vm._data =
+  vm._watchers =
+  vm._userWatchers =
+  vm._watcherList =
+  vm.$el =
+  vm.$parent =
+  vm.$root =
+  vm._children =
+  vm._bindings =
+  vm._directives = null
+  // call the last hook...
+  vm._isDestroyed = true
+  vm._callHook('destroyed')
+  // turn off all instance listeners.
+  vm.$off() 
+}
+
+/**
+ * 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)
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/batcher.js b/vendor/assets/javascripts/bower/vue/src/batcher.js
index 1082ba1..0c8d88d 100644
--- a/vendor/assets/javascripts/bower/vue/src/batcher.js
+++ b/vendor/assets/javascripts/bower/vue/src/batcher.js
@@ -1,45 +1,65 @@
-var utils = require('./utils')
+var _ = require('./util')
+
+/**
+ * The Batcher maintains a job queue to be run
+ * async on the next event loop.
+ */
 
 function Batcher () {
-    this.reset()
+  this.reset()
 }
 
-var BatcherProto = Batcher.prototype
+var p = Batcher.prototype
 
-BatcherProto.push = function (job) {
-    if (!job.id || !this.has[job.id]) {
-        this.queue.push(job)
-        this.has[job.id] = job
-        if (!this.waiting) {
-            this.waiting = true
-            utils.nextTick(utils.bind(this.flush, this))
-        }
-    } else if (job.override) {
-        var oldJob = this.has[job.id]
-        oldJob.cancelled = true
-        this.queue.push(job)
-        this.has[job.id] = job
+/**
+ * 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
+ */
+
+p.push = function (job) {
+  if (!job.id || !this.has[job.id] || this.flushing) {
+    this.queue.push(job)
+    this.has[job.id] = job
+    if (!this.waiting) {
+      this.waiting = true
+      _.nextTick(this.flush, this)
     }
+  }
 }
 
-BatcherProto.flush = function () {
-    // before flush hook
-    if (this._preFlush) this._preFlush()
-    // do not cache length because more jobs might be pushed
-    // as we execute existing jobs
-    for (var i = 0; i < this.queue.length; i++) {
-        var job = this.queue[i]
-        if (!job.cancelled) {
-            job.execute()
-        }
+/**
+ * Flush the queue and run the jobs.
+ * Will call a preFlush hook if has one.
+ */
+
+p.flush = function () {
+  this.flushing = true
+  // do not cache length because more jobs might be pushed
+  // as we run existing jobs
+  for (var i = 0; i < this.queue.length; i++) {
+    var job = this.queue[i]
+    if (!job.cancelled) {
+      job.run()
     }
-    this.reset()
+  }
+  this.reset()
 }
 
-BatcherProto.reset = function () {
-    this.has = utils.hash()
-    this.queue = []
-    this.waiting = false
+/**
+ * Reset the batcher's state.
+ */
+
+p.reset = function () {
+  this.has = {}
+  this.queue = []
+  this.waiting = false
+  this.flushing = false
 }
 
 module.exports = Batcher
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/binding.js b/vendor/assets/javascripts/bower/vue/src/binding.js
index bd554d4..b272b3f 100644
--- a/vendor/assets/javascripts/bower/vue/src/binding.js
+++ b/vendor/assets/javascripts/bower/vue/src/binding.js
@@ -1,103 +1,50 @@
-var Batcher        = require('./batcher'),
-    bindingBatcher = new Batcher(),
-    bindingId      = 1
+var uid = 0
 
 /**
- *  Binding class.
+ * A binding is an observable that can have multiple
+ * directives subscribing to it.
  *
- *  each property on the viewmodel has one corresponding Binding object
- *  which has multiple directive instances on the DOM
- *  and multiple computed property dependents
+ * @constructor
  */
-function Binding (compiler, key, isExp, isFn) {
-    this.id = bindingId++
-    this.value = undefined
-    this.isExp = !!isExp
-    this.isFn = isFn
-    this.root = !this.isExp && key.indexOf('.') === -1
-    this.compiler = compiler
-    this.key = key
-    this.dirs = []
-    this.subs = []
-    this.deps = []
-    this.unbound = false
+
+function Binding () {
+  this.id = ++uid
+  this.subs = []
 }
 
-var BindingProto = Binding.prototype
+var p = Binding.prototype
 
 /**
- *  Update value and queue instance updates.
+ * Add a directive subscriber.
+ *
+ * @param {Directive} sub
  */
-BindingProto.update = function (value) {
-    if (!this.isComputed || this.isFn) {
-        this.value = value
-    }
-    if (this.dirs.length || this.subs.length) {
-        var self = this
-        bindingBatcher.push({
-            id: this.id,
-            execute: function () {
-                if (!self.unbound) {
-                    self._update()
-                }
-            }
-        })
-    }
+
+p.addSub = function (sub) {
+  this.subs.push(sub)
 }
 
 /**
- *  Actually update the directives.
+ * Remove a directive subscriber.
+ *
+ * @param {Directive} sub
  */
-BindingProto._update = function () {
-    var i = this.dirs.length,
-        value = this.val()
-    while (i--) {
-        this.dirs[i].$update(value)
-    }
-    this.pub()
+
+p.removeSub = function (sub) {
+  if (this.subs.length) {
+    var i = this.subs.indexOf(sub)
+    if (i > -1) this.subs.splice(i, 1)
+  }
 }
 
 /**
- *  Return the valuated value regardless
- *  of whether it is computed or not
+ * Notify all subscribers of a new value.
  */
-BindingProto.val = function () {
-    return this.isComputed && !this.isFn
-        ? this.value.$get()
-        : this.value
-}
 
-/**
- *  Notify computed properties that depend on this binding
- *  to update themselves
- */
-BindingProto.pub = function () {
-    var i = this.subs.length
-    while (i--) {
-        this.subs[i].update()
-    }
-}
-
-/**
- *  Unbind the binding, remove itself from all of its dependencies
- */
-BindingProto.unbind = function () {
-    // Indicate this has been unbound.
-    // It's possible this binding will be in
-    // the batcher's flush queue when its owner
-    // compiler has already been destroyed.
-    this.unbound = true
-    var i = this.dirs.length
-    while (i--) {
-        this.dirs[i].$unbind()
-    }
-    i = this.deps.length
-    var subs
-    while (i--) {
-        subs = this.deps[i].subs
-        var j = subs.indexOf(this)
-        if (j > -1) subs.splice(j, 1)
-    }
+p.notify = function () {
+  for (var i = 0, l = this.subs.length; i < l; i++) {
+    this.subs[i].update()
+  }
 }
 
 module.exports = Binding
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/cache.js b/vendor/assets/javascripts/bower/vue/src/cache.js
new file mode 100644
index 0000000..13a2b12
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/cache.js
@@ -0,0 +1,112 @@
+/**
+ * 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 {
+    this.head = entry
+  }
+  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
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/compile/compile.js b/vendor/assets/javascripts/bower/vue/src/compile/compile.js
new file mode 100644
index 0000000..5da90ee
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/compile/compile.js
@@ -0,0 +1,537 @@
+var _ = require('../util')
+var config = require('../config')
+var textParser = require('../parse/text')
+var dirParser = require('../parse/directive')
+var templateParser = require('../parse/template')
+
+/**
+ * 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 {Element|DocumentFragment} el
+ * @param {Object} options
+ * @param {Boolean} partial
+ * @return {Function}
+ */
+
+module.exports = function compile (el, options, partial) {
+  var params = !partial && options.paramAttributes
+  var paramsLinkFn = params
+    ? compileParamAttributes(el, params, options)
+    : null
+  var nodeLinkFn = el instanceof DocumentFragment
+    ? null
+    : compileNode(el, options)
+  var childLinkFn =
+    (!nodeLinkFn || !nodeLinkFn.terminal) &&
+    el.hasChildNodes()
+      ? compileNodeList(el.childNodes, options)
+      : null
+
+  /**
+   * A 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}
+   */
+
+  return function link (vm, el) {
+    var originalDirCount = vm._directives.length
+    if (paramsLinkFn) paramsLinkFn(vm, el)
+    if (nodeLinkFn) nodeLinkFn(vm, el)
+    if (childLinkFn) childLinkFn(vm, el.childNodes)
+
+    /**
+     * If this is a partial compile, the linker function
+     * returns an unlink function that tearsdown all
+     * directives instances generated during the partial
+     * linking.
+     */
+
+    if (partial) {
+      var dirs = vm._directives.slice(originalDirCount)
+      return function unlink () {
+        var i = dirs.length
+        while (i--) {
+          dirs[i]._teardown()
+        }
+        i = vm._directives.indexOf(dirs[0])
+        vm._directives.splice(i, dirs.length)
+      }
+    }
+  }
+}
+
+/**
+ * Compile a node and return a nodeLinkFn based on the
+ * node type.
+ *
+ * @param {Node} node
+ * @param {Object} options
+ * @return {Function|undefined}
+ */
+
+function compileNode (node, options) {
+  var type = node.nodeType
+  if (type === 1 && node.tagName !== 'SCRIPT') {
+    return compileElement(node, options)
+  } else if (type === 3 && config.interpolate) {
+    return compileTextNode(node, options)
+  }
+}
+
+/**
+ * Compile an element and return a nodeLinkFn.
+ *
+ * @param {Element} el
+ * @param {Object} options
+ * @return {Function|null}
+ */
+
+function compileElement (el, options) {
+  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) {
+      var directives = collectDirectives(el, options)
+      linkFn = directives.length
+        ? makeDirectivesLinkFn(directives)
+        : null
+    }
+  }
+  // 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 multi-directive link function.
+ *
+ * @param {Array} directives
+ * @return {Function} directivesLinkFn
+ */
+
+function makeDirectivesLinkFn (directives) {
+  return function directivesLinkFn (vm, el) {
+    // 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)
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Compile a textNode and return a nodeLinkFn.
+ *
+ * @param {TextNode} node
+ * @param {Object} options
+ * @return {Function|null} textNodeLinkFn
+ */
+
+function compileTextNode (node, options) {
+  var tokens = textParser.parse(node.nodeValue)
+  if (!tokens) {
+    return null
+  }
+  var frag = document.createDocumentFragment()
+  var dirs = options.directives
+  var el, token, value
+  for (var i = 0, l = tokens.length; i < l; i++) {
+    token = tokens[i]
+    value = token.value
+    if (token.tag) {
+      if (token.oneTime) {
+        el = document.createTextNode(value)
+      } else {
+        if (token.html) {
+          el = document.createComment('v-html')
+          token.type = 'html'
+          token.def = dirs.html
+          token.descriptor = dirParser.parse(value)[0]
+        } else if (token.partial) {
+          el = document.createComment('v-partial')
+          token.type = 'partial'
+          token.def = dirs.partial
+          token.descriptor = dirParser.parse(value)[0]
+        } else {
+          // IE will clean up empty textNodes during
+          // frag.cloneNode(true), so we have to give it
+          // something here...
+          el = document.createTextNode(' ')
+          token.type = 'text'
+          token.def = dirs.text
+          token.descriptor = dirParser.parse(value)[0]
+        }
+      }
+    } else {
+      el = document.createTextNode(value)
+    }
+    frag.appendChild(el)
+  }
+  return makeTextNodeLinkFn(tokens, frag, options)
+}
+
+/**
+ * Build a function that processes a textNode.
+ *
+ * @param {Array<Object>} tokens
+ * @param {DocumentFragment} frag
+ */
+
+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.nodeValue = value
+          }
+        } else {
+          vm._bindDir(token.type, node,
+                      token.descriptor, token.def)
+        }
+      }
+    }
+    _.replace(el, fragClone)
+  }
+}
+
+/**
+ * Compile a node list and return a childLinkFn.
+ *
+ * @param {NodeList} nodeList
+ * @param {Object} options
+ * @return {Function|undefined}
+ */
+
+function compileNodeList (nodeList, options) {
+  var linkFns = []
+  var nodeLinkFn, childLinkFn, node
+  for (var i = 0, l = nodeList.length; i < l; i++) {
+    node = nodeList[i]
+    nodeLinkFn = compileNode(node, options)
+    childLinkFn =
+      (!nodeLinkFn || !nodeLinkFn.terminal) &&
+      node.hasChildNodes()
+        ? compileNodeList(node.childNodes, options)
+        : null
+    linkFns.push(nodeLinkFn, childLinkFn)
+  }
+  return linkFns.length
+    ? makeChildLinkFn(linkFns)
+    : null
+}
+
+/**
+ * Make a child link function for a node's childNodes.
+ *
+ * @param {Array<Function>} linkFns
+ * @return {Function} childLinkFn
+ */
+
+function makeChildLinkFn (linkFns) {
+  return function childLinkFn (vm, nodes) {
+    // stablize nodes
+    nodes = _.toArray(nodes)
+    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++]
+      if (nodeLinkFn) {
+        nodeLinkFn(vm, node)
+      }
+      if (childrenLinkFn) {
+        childrenLinkFn(vm, node.childNodes)
+      }
+    }
+  }
+}
+
+/**
+ * Compile param attributes on a root element and return
+ * a paramAttributes link function.
+ *
+ * @param {Element} el
+ * @param {Array} attrs
+ * @param {Object} options
+ * @return {Function} paramsLinkFn
+ */
+
+function compileParamAttributes (el, attrs, options) {
+  var params = []
+  var i = attrs.length
+  var name, value, param
+  while (i--) {
+    name = attrs[i]
+    value = el.getAttribute(name)
+    if (value !== null) {
+      param = {
+        name: name,
+        value: value
+      }
+      var tokens = textParser.parse(value)
+      if (tokens) {
+        el.removeAttribute(name)
+        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)
+    }
+  }
+  return makeParamsLinkFn(params, options)
+}
+
+/**
+ * Build a function that applies param attributes to a vm.
+ *
+ * @param {Array} params
+ * @param {Object} options
+ * @return {Function} paramsLinkFn
+ */
+
+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)
+      }
+    }
+  }
+}
+
+/**
+ * Check an element for terminal directives in fixed order.
+ * If it finds one, return a terminal link function.
+ *
+ * @param {Element} el
+ * @param {Object} options
+ * @return {Function} terminalLinkFn
+ */
+
+var terminalDirectives = [
+  'repeat',
+  'if',
+  'component'
+]
+
+function skip () {}
+skip.terminal = true
+
+function checkTerminalDirectives (el, options) {
+  if (_.attr(el, 'pre') !== null) {
+    return skip
+  }
+  var value, dirName
+  /* jshint boss: true */
+  for (var i = 0; i < 3; i++) {
+    dirName = terminalDirectives[i]
+    if (value = _.attr(el, dirName)) {
+      return makeTeriminalLinkFn(el, dirName, value, options)
+    }
+  }
+}
+
+/**
+ * Build a link function for a terminal directive.
+ *
+ * @param {Element} el
+ * @param {String} dirName
+ * @param {String} value
+ * @param {Object} options
+ * @return {Function} terminalLinkFn
+ */
+
+function makeTeriminalLinkFn (el, dirName, value, options) {
+  var descriptor = dirParser.parse(value)[0]
+  var def = options.directives[dirName]
+  // special case: we need to collect directives found
+  // on a component root node, but defined in the parent
+  // template. These directives need to be compiled in
+  // the parent scope.
+  if (dirName === 'component') {
+    var dirs = collectDirectives(el, options, true)
+    el._parentLinker = dirs.length
+      ? makeDirectivesLinkFn(dirs)
+      : null
+  }
+  var terminalLinkFn = function (vm, el) {
+    vm._bindDir(dirName, el, descriptor, def)
+  }
+  terminalLinkFn.terminal = true
+  return terminalLinkFn
+}
+
+/**
+ * Collect the directives on an element.
+ *
+ * @param {Element} el
+ * @param {Object} options
+ * @param {Boolean} asParent
+ * @return {Array}
+ */
+
+function collectDirectives (el, options, asParent) {
+  var attrs = _.toArray(el.attributes)
+  var i = attrs.length
+  var dirs = []
+  var attr, attrName, dir, dirName, dirDef
+  while (i--) {
+    attr = attrs[i]
+    attrName = attr.name
+    if (attrName.indexOf(config.prefix) === 0) {
+      dirName = attrName.slice(config.prefix.length)
+      if (
+        asParent &&
+        (dirName === 'with' || dirName === 'ref')
+      ) {
+        continue
+      }
+      dirDef = options.directives[dirName]
+      _.assertAsset(dirDef, 'directive', dirName)
+      if (dirDef) {
+        dirs.push({
+          name: dirName,
+          descriptors: dirParser.parse(attr.value),
+          def: dirDef
+        })
+      }
+    } else if (config.interpolate) {
+      dir = collectAttrDirective(el, attrName, attr.value,
+                                 options)
+      if (dir) {
+        dirs.push(dir)
+      }
+    }
+  }
+  // sort by priority, LOW to HIGH
+  dirs.sort(directiveComparator)
+  return dirs
+}
+
+/**
+ * Check an attribute for potential dynamic bindings,
+ * and return a directive object.
+ *
+ * @param {Element} el
+ * @param {String} name
+ * @param {String} value
+ * @param {Object} options
+ * @return {Object}
+ */
+
+function collectAttrDirective (el, 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)
+          }
+    }
+  }
+}
+
+/**
+ * Directive priority sort comparator
+ *
+ * @param {Object} a
+ * @param {Object} b
+ */
+
+function directiveComparator (a, b) {
+  a = a.def.priority || 0
+  b = b.def.priority || 0
+  return a > b ? 1 : -1
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/compile/transclude.js b/vendor/assets/javascripts/bower/vue/src/compile/transclude.js
new file mode 100644
index 0000000..ac6b1e8
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/compile/transclude.js
@@ -0,0 +1,163 @@
+var _ = require('../util')
+var templateParser = require('../parse/template')
+
+/**
+ * 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) {
+  // 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 {
+    collectRawContent(el)
+    if (options.replace) {
+      if (frag.childNodes.length > 1) {
+        transcludeContent(frag)
+        return frag
+      } else {
+        var replacer = frag.firstChild
+        _.copyAttributes(el, replacer)
+        transcludeContent(replacer)
+        return replacer
+      }
+    } else {
+      el.appendChild(frag)
+      transcludeContent(el)
+      return el
+    }
+  }
+}
+
+/**
+ * Collect raw content inside $el before they are
+ * replaced by template content.
+ */
+
+var rawContent
+function collectRawContent (el) {
+  var child
+  rawContent = null
+  if (el.hasChildNodes()) {
+    rawContent = document.createElement('div')
+    /* jshint boss:true */
+    while (child = el.firstChild) {
+      rawContent.appendChild(child)
+    }
+  }
+}
+
+/**
+ * Resolve <content> insertion points mimicking the behavior
+ * of the Shadow DOM spec:
+ *
+ *   http://w3c.github.io/webcomponents/spec/shadow/#insertion-points
+ *
+ * @param {Element|DocumentFragment} el
+ */
+
+function transcludeContent (el) {
+  var outlets = getOutlets(el)
+  var i = outlets.length
+  if (!i) return
+  var outlet, select, selected, j, main
+  // first pass, collect corresponding content
+  // for each outlet.
+  while (i--) {
+    outlet = outlets[i]
+    if (rawContent) {
+      select = outlet.getAttribute('select')
+      if (select) {  // select content
+        selected = rawContent.querySelectorAll(select)
+        outlet.content = _.toArray(
+          selected.length
+            ? selected
+            : 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(rawContent.childNodes))
+  }
+}
+
+/**
+ * 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.
+ *
+ * @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)
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/compiler.js b/vendor/assets/javascripts/bower/vue/src/compiler.js
deleted file mode 100644
index 45468ad..0000000
--- a/vendor/assets/javascripts/bower/vue/src/compiler.js
+++ /dev/null
@@ -1,1037 +0,0 @@
-var Emitter     = require('./emitter'),
-    Observer    = require('./observer'),
-    config      = require('./config'),
-    utils       = require('./utils'),
-    Binding     = require('./binding'),
-    Directive   = require('./directive'),
-    TextParser  = require('./text-parser'),
-    DepsParser  = require('./deps-parser'),
-    ExpParser   = require('./exp-parser'),
-    ViewModel,
-    
-    // cache methods
-    slice       = [].slice,
-    extend      = utils.extend,
-    hasOwn      = ({}).hasOwnProperty,
-    def         = Object.defineProperty,
-
-    // hooks to register
-    hooks = [
-        'created', 'ready',
-        'beforeDestroy', 'afterDestroy',
-        'attached', 'detached'
-    ],
-
-    // list of priority directives
-    // that needs to be checked in specific order
-    priorityDirectives = [
-        'if',
-        'repeat',
-        'view',
-        'component'
-    ]
-
-/**
- *  The DOM compiler
- *  scans a DOM node and compile bindings for a ViewModel
- */
-function Compiler (vm, options) {
-
-    var compiler = this,
-        key, i
-
-    // default state
-    compiler.init       = true
-    compiler.destroyed  = false
-
-    // process and extend options
-    options = compiler.options = options || {}
-    utils.processOptions(options)
-
-    // copy compiler options
-    extend(compiler, options.compilerOptions)
-    // repeat indicates this is a v-repeat instance
-    compiler.repeat   = compiler.repeat || false
-    // expCache will be shared between v-repeat instances
-    compiler.expCache = compiler.expCache || {}
-
-    // initialize element
-    var el = compiler.el = compiler.setupElement(options)
-    utils.log('\nnew VM instance: ' + el.tagName + '\n')
-
-    // set other compiler properties
-    compiler.vm       = el.vue_vm = vm
-    compiler.bindings = utils.hash()
-    compiler.dirs     = []
-    compiler.deferred = []
-    compiler.computed = []
-    compiler.children = []
-    compiler.emitter  = new Emitter(vm)
-
-    // VM ---------------------------------------------------------------------
-
-    // set VM properties
-    vm.$         = {}
-    vm.$el       = el
-    vm.$options  = options
-    vm.$compiler = compiler
-    vm.$event    = null
-
-    // set parent & root
-    var parentVM = options.parent
-    if (parentVM) {
-        compiler.parent = parentVM.$compiler
-        parentVM.$compiler.children.push(compiler)
-        vm.$parent = parentVM
-        // inherit lazy option
-        if (!('lazy' in options)) {
-            options.lazy = compiler.parent.options.lazy
-        }
-    }
-    vm.$root = getRoot(compiler).vm
-
-    // DATA -------------------------------------------------------------------
-
-    // setup observer
-    // this is necesarry for all hooks and data observation events
-    compiler.setupObserver()
-
-    // create bindings for computed properties
-    if (options.methods) {
-        for (key in options.methods) {
-            compiler.createBinding(key)
-        }
-    }
-
-    // create bindings for methods
-    if (options.computed) {
-        for (key in options.computed) {
-            compiler.createBinding(key)
-        }
-    }
-
-    // initialize data
-    var data = compiler.data = options.data || {},
-        defaultData = options.defaultData
-    if (defaultData) {
-        for (key in defaultData) {
-            if (!hasOwn.call(data, key)) {
-                data[key] = defaultData[key]
-            }
-        }
-    }
-
-    // copy paramAttributes
-    var params = options.paramAttributes
-    if (params) {
-        i = params.length
-        while (i--) {
-            data[params[i]] = utils.checkNumber(
-                compiler.eval(
-                    el.getAttribute(params[i])
-                )
-            )
-        }
-    }
-
-    // copy data properties to vm
-    // so user can access them in the created hook
-    extend(vm, data)
-    vm.$data = data
-
-    // beforeCompile hook
-    compiler.execHook('created')
-
-    // the user might have swapped the data ...
-    data = compiler.data = vm.$data
-
-    // user might also set some properties on the vm
-    // in which case we should copy back to $data
-    var vmProp
-    for (key in vm) {
-        vmProp = vm[key]
-        if (
-            key.charAt(0) !== '$' &&
-            data[key] !== vmProp &&
-            typeof vmProp !== 'function'
-        ) {
-            data[key] = vmProp
-        }
-    }
-
-    // now we can observe the data.
-    // this will convert data properties to getter/setters
-    // and emit the first batch of set events, which will
-    // in turn create the corresponding bindings.
-    compiler.observeData(data)
-
-    // COMPILE ----------------------------------------------------------------
-
-    // before compiling, resolve content insertion points
-    if (options.template) {
-        this.resolveContent()
-    }
-
-    // now parse the DOM and bind directives.
-    // During this stage, we will also create bindings for
-    // encountered keypaths that don't have a binding yet.
-    compiler.compile(el, true)
-
-    // Any directive that creates child VMs are deferred
-    // so that when they are compiled, all bindings on the
-    // parent VM have been created.
-    i = compiler.deferred.length
-    while (i--) {
-        compiler.bindDirective(compiler.deferred[i])
-    }
-    compiler.deferred = null
-
-    // extract dependencies for computed properties.
-    // this will evaluated all collected computed bindings
-    // and collect get events that are emitted.
-    if (this.computed.length) {
-        DepsParser.parse(this.computed)
-    }
-
-    // done!
-    compiler.init = false
-
-    // post compile / ready hook
-    compiler.execHook('ready')
-}
-
-var CompilerProto = Compiler.prototype
-
-/**
- *  Initialize the VM/Compiler's element.
- *  Fill it in with the template if necessary.
- */
-CompilerProto.setupElement = function (options) {
-    // create the node first
-    var el = typeof options.el === 'string'
-        ? document.querySelector(options.el)
-        : options.el || document.createElement(options.tagName || 'div')
-
-    var template = options.template,
-        child, replacer, i, attr, attrs
-
-    if (template) {
-        // collect anything already in there
-        if (el.hasChildNodes()) {
-            this.rawContent = document.createElement('div')
-            /* jshint boss: true */
-            while (child = el.firstChild) {
-                this.rawContent.appendChild(child)
-            }
-        }
-        // replace option: use the first node in
-        // the template directly
-        if (options.replace && template.firstChild === template.lastChild) {
-            replacer = template.firstChild.cloneNode(true)
-            if (el.parentNode) {
-                el.parentNode.insertBefore(replacer, el)
-                el.parentNode.removeChild(el)
-            }
-            // copy over attributes
-            if (el.hasAttributes()) {
-                i = el.attributes.length
-                while (i--) {
-                    attr = el.attributes[i]
-                    replacer.setAttribute(attr.name, attr.value)
-                }
-            }
-            // replace
-            el = replacer
-        } else {
-            el.appendChild(template.cloneNode(true))
-        }
-
-    }
-
-    // apply element options
-    if (options.id) el.id = options.id
-    if (options.className) el.className = options.className
-    attrs = options.attributes
-    if (attrs) {
-        for (attr in attrs) {
-            el.setAttribute(attr, attrs[attr])
-        }
-    }
-
-    return el
-}
-
-/**
- *  Deal with <content> insertion points
- *  per the Web Components spec
- */
-CompilerProto.resolveContent = function () {
-
-    var outlets = slice.call(this.el.getElementsByTagName('content')),
-        raw = this.rawContent,
-        outlet, select, i, j, main
-
-    i = outlets.length
-    if (i) {
-        // first pass, collect corresponding content
-        // for each outlet.
-        while (i--) {
-            outlet = outlets[i]
-            if (raw) {
-                select = outlet.getAttribute('select')
-                if (select) { // select content
-                    outlet.content =
-                        slice.call(raw.querySelectorAll(select))
-                } else { // default content
-                    main = outlet
-                }
-            } else { // fallback content
-                outlet.content =
-                    slice.call(outlet.childNodes)
-            }
-        }
-        // second pass, actually insert the contents
-        for (i = 0, j = outlets.length; i < j; i++) {
-            outlet = outlets[i]
-            if (outlet === main) continue
-            insert(outlet, outlet.content)
-        }
-        // finally insert the main content
-        if (raw && main) {
-            insert(main, slice.call(raw.childNodes))
-        }
-    }
-
-    function insert (outlet, contents) {
-        var parent = outlet.parentNode,
-            i = 0, j = contents.length
-        for (; i < j; i++) {
-            parent.insertBefore(contents[i], outlet)
-        }
-        parent.removeChild(outlet)
-    }
-
-    this.rawContent = null
-}
-
-/**
- *  Setup observer.
- *  The observer listens for get/set/mutate events on all VM
- *  values/objects and trigger corresponding binding updates.
- *  It also listens for lifecycle hooks.
- */
-CompilerProto.setupObserver = function () {
-
-    var compiler = this,
-        bindings = compiler.bindings,
-        options  = compiler.options,
-        observer = compiler.observer = new Emitter(compiler.vm)
-
-    // a hash to hold event proxies for each root level key
-    // so they can be referenced and removed later
-    observer.proxies = {}
-
-    // add own listeners which trigger binding updates
-    observer
-        .on('get', onGet)
-        .on('set', onSet)
-        .on('mutate', onSet)
-
-    // register hooks
-    var i = hooks.length, j, hook, fns
-    while (i--) {
-        hook = hooks[i]
-        fns = options[hook]
-        if (Array.isArray(fns)) {
-            j = fns.length
-            // since hooks were merged with child at head,
-            // we loop reversely.
-            while (j--) {
-                registerHook(hook, fns[j])
-            }
-        } else if (fns) {
-            registerHook(hook, fns)
-        }
-    }
-
-    // broadcast attached/detached hooks
-    observer
-        .on('hook:attached', function () {
-            broadcast(1)
-        })
-        .on('hook:detached', function () {
-            broadcast(0)
-        })
-
-    function onGet (key) {
-        check(key)
-        DepsParser.catcher.emit('get', bindings[key])
-    }
-
-    function onSet (key, val, mutation) {
-        observer.emit('change:' + key, val, mutation)
-        check(key)
-        bindings[key].update(val)
-    }
-
-    function registerHook (hook, fn) {
-        observer.on('hook:' + hook, function () {
-            fn.call(compiler.vm)
-        })
-    }
-
-    function broadcast (event) {
-        var children = compiler.children
-        if (children) {
-            var child, i = children.length
-            while (i--) {
-                child = children[i]
-                if (child.el.parentNode) {
-                    event = 'hook:' + (event ? 'attached' : 'detached')
-                    child.observer.emit(event)
-                    child.emitter.emit(event)
-                }
-            }
-        }
-    }
-
-    function check (key) {
-        if (!bindings[key]) {
-            compiler.createBinding(key)
-        }
-    }
-}
-
-CompilerProto.observeData = function (data) {
-
-    var compiler = this,
-        observer = compiler.observer
-
-    // recursively observe nested properties
-    Observer.observe(data, '', observer)
-
-    // also create binding for top level $data
-    // so it can be used in templates too
-    var $dataBinding = compiler.bindings['$data'] = new Binding(compiler, '$data')
-    $dataBinding.update(data)
-
-    // allow $data to be swapped
-    def(compiler.vm, '$data', {
-        get: function () {
-            compiler.observer.emit('get', '$data')
-            return compiler.data
-        },
-        set: function (newData) {
-            var oldData = compiler.data
-            Observer.unobserve(oldData, '', observer)
-            compiler.data = newData
-            Observer.copyPaths(newData, oldData)
-            Observer.observe(newData, '', observer)
-            update()
-        }
-    })
-
-    // emit $data change on all changes
-    observer
-        .on('set', onSet)
-        .on('mutate', onSet)
-
-    function onSet (key) {
-        if (key !== '$data') update()
-    }
-
-    function update () {
-        $dataBinding.update(compiler.data)
-        observer.emit('change:$data', compiler.data)
-    }
-}
-
-/**
- *  Compile a DOM node (recursive)
- */
-CompilerProto.compile = function (node, root) {
-    var nodeType = node.nodeType
-    if (nodeType === 1 && node.tagName !== 'SCRIPT') { // a normal node
-        this.compileElement(node, root)
-    } else if (nodeType === 3 && config.interpolate) {
-        this.compileTextNode(node)
-    }
-}
-
-/**
- *  Check for a priority directive
- *  If it is present and valid, return true to skip the rest
- */
-CompilerProto.checkPriorityDir = function (dirname, node, root) {
-    var expression, directive, Ctor
-    if (
-        dirname === 'component' &&
-        root !== true &&
-        (Ctor = this.resolveComponent(node, undefined, true))
-    ) {
-        directive = this.parseDirective(dirname, '', node)
-        directive.Ctor = Ctor
-    } else {
-        expression = utils.attr(node, dirname)
-        directive = expression && this.parseDirective(dirname, expression, node)
-    }
-    if (directive) {
-        if (root === true) {
-            utils.warn(
-                'Directive v-' + dirname + ' cannot be used on an already instantiated ' +
-                'VM\'s root node. Use it from the parent\'s template instead.'
-            )
-            return
-        }
-        this.deferred.push(directive)
-        return true
-    }
-}
-
-/**
- *  Compile normal directives on a node
- */
-CompilerProto.compileElement = function (node, root) {
-
-    // textarea is pretty annoying
-    // because its value creates childNodes which
-    // we don't want to compile.
-    if (node.tagName === 'TEXTAREA' && node.value) {
-        node.value = this.eval(node.value)
-    }
-
-    // only compile if this element has attributes
-    // or its tagName contains a hyphen (which means it could
-    // potentially be a custom element)
-    if (node.hasAttributes() || node.tagName.indexOf('-') > -1) {
-
-        // skip anything with v-pre
-        if (utils.attr(node, 'pre') !== null) {
-            return
-        }
-
-        var i, l, j, k
-
-        // check priority directives.
-        // if any of them are present, it will take over the node with a childVM
-        // so we can skip the rest
-        for (i = 0, l = priorityDirectives.length; i < l; i++) {
-            if (this.checkPriorityDir(priorityDirectives[i], node, root)) {
-                return
-            }
-        }
-
-        // check transition & animation properties
-        node.vue_trans  = utils.attr(node, 'transition')
-        node.vue_anim   = utils.attr(node, 'animation')
-        node.vue_effect = this.eval(utils.attr(node, 'effect'))
-
-        var prefix = config.prefix + '-',
-            params = this.options.paramAttributes,
-            attr, attrname, isDirective, exp, directives, directive, dirname
-
-        // v-with has special priority among the rest
-        // it needs to pull in the value from the parent before
-        // computed properties are evaluated, because at this stage
-        // the computed properties have not set up their dependencies yet.
-        if (root) {
-            var withExp = utils.attr(node, 'with')
-            if (withExp) {
-                directives = this.parseDirective('with', withExp, node, true)
-                for (j = 0, k = directives.length; j < k; j++) {
-                    this.bindDirective(directives[j], this.parent)
-                }
-            }
-        }
-
-        var attrs = slice.call(node.attributes)
-        for (i = 0, l = attrs.length; i < l; i++) {
-
-            attr = attrs[i]
-            attrname = attr.name
-            isDirective = false
-
-            if (attrname.indexOf(prefix) === 0) {
-                // a directive - split, parse and bind it.
-                isDirective = true
-                dirname = attrname.slice(prefix.length)
-                // build with multiple: true
-                directives = this.parseDirective(dirname, attr.value, node, true)
-                // loop through clauses (separated by ",")
-                // inside each attribute
-                for (j = 0, k = directives.length; j < k; j++) {
-                    this.bindDirective(directives[j])
-                }
-            } else if (config.interpolate) {
-                // non directive attribute, check interpolation tags
-                exp = TextParser.parseAttr(attr.value)
-                if (exp) {
-                    directive = this.parseDirective('attr', exp, node)
-                    directive.arg = attrname
-                    if (params && params.indexOf(attrname) > -1) {
-                        // a param attribute... we should use the parent binding
-                        // to avoid circular updates like size={{size}}
-                        this.bindDirective(directive, this.parent)
-                    } else {
-                        this.bindDirective(directive)
-                    }
-                }
-            }
-
-            if (isDirective && dirname !== 'cloak') {
-                node.removeAttribute(attrname)
-            }
-        }
-
-    }
-
-    // recursively compile childNodes
-    if (node.hasChildNodes()) {
-        slice.call(node.childNodes).forEach(this.compile, this)
-    }
-}
-
-/**
- *  Compile a text node
- */
-CompilerProto.compileTextNode = function (node) {
-
-    var tokens = TextParser.parse(node.nodeValue)
-    if (!tokens) return
-    var el, token, directive
-
-    for (var i = 0, l = tokens.length; i < l; i++) {
-
-        token = tokens[i]
-        directive = null
-
-        if (token.key) { // a binding
-            if (token.key.charAt(0) === '>') { // a partial
-                el = document.createComment('ref')
-                directive = this.parseDirective('partial', token.key.slice(1), el)
-            } else {
-                if (!token.html) { // text binding
-                    el = document.createTextNode('')
-                    directive = this.parseDirective('text', token.key, el)
-                } else { // html binding
-                    el = document.createComment(config.prefix + '-html')
-                    directive = this.parseDirective('html', token.key, el)
-                }
-            }
-        } else { // a plain string
-            el = document.createTextNode(token)
-        }
-
-        // insert node
-        node.parentNode.insertBefore(el, node)
-        // bind directive
-        this.bindDirective(directive)
-
-    }
-    node.parentNode.removeChild(node)
-}
-
-/**
- *  Parse a directive name/value pair into one or more
- *  directive instances
- */
-CompilerProto.parseDirective = function (name, value, el, multiple) {
-    var compiler = this,
-        definition = compiler.getOption('directives', name)
-    if (definition) {
-        // parse into AST-like objects
-        var asts = Directive.parse(value)
-        return multiple
-            ? asts.map(build)
-            : build(asts[0])
-    }
-    function build (ast) {
-        return new Directive(name, ast, definition, compiler, el)
-    }
-}
-
-/**
- *  Add a directive instance to the correct binding & viewmodel
- */
-CompilerProto.bindDirective = function (directive, bindingOwner) {
-
-    if (!directive) return
-
-    // keep track of it so we can unbind() later
-    this.dirs.push(directive)
-
-    // for empty or literal directives, simply call its bind()
-    // and we're done.
-    if (directive.isEmpty || directive.isLiteral) {
-        if (directive.bind) directive.bind()
-        return
-    }
-
-    // otherwise, we got more work to do...
-    var binding,
-        compiler = bindingOwner || this,
-        key      = directive.key
-
-    if (directive.isExp) {
-        // expression bindings are always created on current compiler
-        binding = compiler.createBinding(key, directive)
-    } else {
-        // recursively locate which compiler owns the binding
-        while (compiler) {
-            if (compiler.hasKey(key)) {
-                break
-            } else {
-                compiler = compiler.parent
-            }
-        }
-        compiler = compiler || this
-        binding = compiler.bindings[key] || compiler.createBinding(key)
-    }
-    binding.dirs.push(directive)
-    directive.binding = binding
-
-    var value = binding.val()
-    // invoke bind hook if exists
-    if (directive.bind) {
-        directive.bind(value)
-    }
-    // set initial value
-    directive.$update(value, true)
-}
-
-/**
- *  Create binding and attach getter/setter for a key to the viewmodel object
- */
-CompilerProto.createBinding = function (key, directive) {
-
-    utils.log('  created binding: ' + key)
-
-    var compiler = this,
-        methods  = compiler.options.methods,
-        isExp    = directive && directive.isExp,
-        isFn     = (directive && directive.isFn) || (methods && methods[key]),
-        bindings = compiler.bindings,
-        computed = compiler.options.computed,
-        binding  = new Binding(compiler, key, isExp, isFn)
-
-    if (isExp) {
-        // expression bindings are anonymous
-        compiler.defineExp(key, binding, directive)
-    } else if (isFn) {
-        bindings[key] = binding
-        compiler.defineVmProp(key, binding, methods[key])
-    } else {
-        bindings[key] = binding
-        if (binding.root) {
-            // this is a root level binding. we need to define getter/setters for it.
-            if (computed && computed[key]) {
-                // computed property
-                compiler.defineComputed(key, binding, computed[key])
-            } else if (key.charAt(0) !== '$') {
-                // normal property
-                compiler.defineDataProp(key, binding)
-            } else {
-                // properties that start with $ are meta properties
-                // they should be kept on the vm but not in the data object.
-                compiler.defineVmProp(key, binding, compiler.data[key])
-                delete compiler.data[key]
-            }
-        } else if (computed && computed[utils.baseKey(key)]) {
-            // nested path on computed property
-            compiler.defineExp(key, binding)
-        } else {
-            // ensure path in data so that computed properties that
-            // access the path don't throw an error and can collect
-            // dependencies
-            Observer.ensurePath(compiler.data, key)
-            var parentKey = key.slice(0, key.lastIndexOf('.'))
-            if (!bindings[parentKey]) {
-                // this is a nested value binding, but the binding for its parent
-                // has not been created yet. We better create that one too.
-                compiler.createBinding(parentKey)
-            }
-        }
-    }
-    return binding
-}
-
-/**
- *  Define the getter/setter to proxy a root-level
- *  data property on the VM
- */
-CompilerProto.defineDataProp = function (key, binding) {
-    var compiler = this,
-        data     = compiler.data,
-        ob       = data.__emitter__
-
-    // make sure the key is present in data
-    // so it can be observed
-    if (!(hasOwn.call(data, key))) {
-        data[key] = undefined
-    }
-
-    // if the data object is already observed, but the key
-    // is not observed, we need to add it to the observed keys.
-    if (ob && !(hasOwn.call(ob.values, key))) {
-        Observer.convertKey(data, key)
-    }
-
-    binding.value = data[key]
-
-    def(compiler.vm, key, {
-        get: function () {
-            return compiler.data[key]
-        },
-        set: function (val) {
-            compiler.data[key] = val
-        }
-    })
-}
-
-/**
- *  Define a vm property, e.g. $index, $key, or mixin methods
- *  which are bindable but only accessible on the VM,
- *  not in the data.
- */
-CompilerProto.defineVmProp = function (key, binding, value) {
-    var ob = this.observer
-    binding.value = value
-    def(this.vm, key, {
-        get: function () {
-            if (Observer.shouldGet) ob.emit('get', key)
-            return binding.value
-        },
-        set: function (val) {
-            ob.emit('set', key, val)
-        }
-    })
-}
-
-/**
- *  Define an expression binding, which is essentially
- *  an anonymous computed property
- */
-CompilerProto.defineExp = function (key, binding, directive) {
-    var computedKey = directive && directive.computedKey,
-        exp         = computedKey ? directive.expression : key,
-        getter      = this.expCache[exp]
-    if (!getter) {
-        getter = this.expCache[exp] = ExpParser.parse(computedKey || key, this)
-    }
-    if (getter) {
-        this.markComputed(binding, getter)
-    }
-}
-
-/**
- *  Define a computed property on the VM
- */
-CompilerProto.defineComputed = function (key, binding, value) {
-    this.markComputed(binding, value)
-    def(this.vm, key, {
-        get: binding.value.$get,
-        set: binding.value.$set
-    })
-}
-
-/**
- *  Process a computed property binding
- *  so its getter/setter are bound to proper context
- */
-CompilerProto.markComputed = function (binding, value) {
-    binding.isComputed = true
-    // bind the accessors to the vm
-    if (binding.isFn) {
-        binding.value = value
-    } else {
-        if (typeof value === 'function') {
-            value = { $get: value }
-        }
-        binding.value = {
-            $get: utils.bind(value.$get, this.vm),
-            $set: value.$set
-                ? utils.bind(value.$set, this.vm)
-                : undefined
-        }
-    }
-    // keep track for dep parsing later
-    this.computed.push(binding)
-}
-
-/**
- *  Retrive an option from the compiler
- */
-CompilerProto.getOption = function (type, id, silent) {
-    var opts = this.options,
-        parent = this.parent,
-        globalAssets = config.globalAssets,
-        res = (opts[type] && opts[type][id]) || (
-            parent
-                ? parent.getOption(type, id, silent)
-                : globalAssets[type] && globalAssets[type][id]
-        )
-    if (!res && !silent && typeof id === 'string') {
-        utils.warn('Unknown ' + type.slice(0, -1) + ': ' + id)
-    }
-    return res
-}
-
-/**
- *  Emit lifecycle events to trigger hooks
- */
-CompilerProto.execHook = function (event) {
-    event = 'hook:' + event
-    this.observer.emit(event)
-    this.emitter.emit(event)
-}
-
-/**
- *  Check if a compiler's data contains a keypath
- */
-CompilerProto.hasKey = function (key) {
-    var baseKey = utils.baseKey(key)
-    return hasOwn.call(this.data, baseKey) ||
-        hasOwn.call(this.vm, baseKey)
-}
-
-/**
- *  Do a one-time eval of a string that potentially
- *  includes bindings. It accepts additional raw data
- *  because we need to dynamically resolve v-component
- *  before a childVM is even compiled...
- */
-CompilerProto.eval = function (exp, data) {
-    var parsed = TextParser.parseAttr(exp)
-    return parsed
-        ? ExpParser.eval(parsed, this, data)
-        : exp
-}
-
-/**
- *  Resolve a Component constructor for an element
- *  with the data to be used
- */
-CompilerProto.resolveComponent = function (node, data, test) {
-
-    // late require to avoid circular deps
-    ViewModel = ViewModel || require('./viewmodel')
-
-    var exp     = utils.attr(node, 'component'),
-        tagName = node.tagName,
-        id      = this.eval(exp, data),
-        tagId   = (tagName.indexOf('-') > 0 && tagName.toLowerCase()),
-        Ctor    = this.getOption('components', id || tagId, true)
-
-    if (id && !Ctor) {
-        utils.warn('Unknown component: ' + id)
-    }
-
-    return test
-        ? exp === ''
-            ? ViewModel
-            : Ctor
-        : Ctor || ViewModel
-}
-
-/**
- *  Unbind and remove element
- */
-CompilerProto.destroy = function (noRemove) {
-
-    // avoid being called more than once
-    // this is irreversible!
-    if (this.destroyed) return
-
-    var compiler = this,
-        i, j, key, dir, dirs, binding,
-        vm          = compiler.vm,
-        el          = compiler.el,
-        directives  = compiler.dirs,
-        computed    = compiler.computed,
-        bindings    = compiler.bindings,
-        children    = compiler.children,
-        parent      = compiler.parent
-
-    compiler.execHook('beforeDestroy')
-
-    // unobserve data
-    Observer.unobserve(compiler.data, '', compiler.observer)
-
-    // destroy all children
-    // do not remove their elements since the parent
-    // may have transitions and the children may not
-    i = children.length
-    while (i--) {
-        children[i].destroy(true)
-    }
-
-    // unbind all direcitves
-    i = directives.length
-    while (i--) {
-        dir = directives[i]
-        // if this directive is an instance of an external binding
-        // e.g. a directive that refers to a variable on the parent VM
-        // we need to remove it from that binding's directives
-        // * empty and literal bindings do not have binding.
-        if (dir.binding && dir.binding.compiler !== compiler) {
-            dirs = dir.binding.dirs
-            if (dirs) {
-                j = dirs.indexOf(dir)
-                if (j > -1) dirs.splice(j, 1)
-            }
-        }
-        dir.$unbind()
-    }
-
-    // unbind all computed, anonymous bindings
-    i = computed.length
-    while (i--) {
-        computed[i].unbind()
-    }
-
-    // unbind all keypath bindings
-    for (key in bindings) {
-        binding = bindings[key]
-        if (binding) {
-            binding.unbind()
-        }
-    }
-
-    // remove self from parent
-    if (parent) {
-        j = parent.children.indexOf(compiler)
-        if (j > -1) parent.children.splice(j, 1)
-    }
-
-    // finally remove dom element
-    if (!noRemove) {
-        if (el === document.body) {
-            el.innerHTML = ''
-        } else {
-            vm.$remove()
-        }
-    }
-    el.vue_vm = null
-
-    compiler.destroyed = true
-    // emit destroy hook
-    compiler.execHook('afterDestroy')
-
-    // finally, unregister all listeners
-    compiler.observer.off()
-    compiler.emitter.off()
-}
-
-// Helpers --------------------------------------------------------------------
-
-/**
- *  shorthand for getting root compiler
- */
-function getRoot (compiler) {
-    while (compiler.parent) {
-        compiler = compiler.parent
-    }
-    return compiler
-}
-
-module.exports = Compiler
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/config.js b/vendor/assets/javascripts/bower/vue/src/config.js
index 9a18434..c306b5d 100644
--- a/vendor/assets/javascripts/bower/vue/src/config.js
+++ b/vendor/assets/javascripts/bower/vue/src/config.js
@@ -1,19 +1,79 @@
-var TextParser = require('./text-parser')
-
 module.exports = {
-    prefix         : 'v',
-    debug          : false,
-    silent         : false,
-    enterClass     : 'v-enter',
-    leaveClass     : 'v-leave',
-    interpolate    : true
+
+  /**
+   * 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,
+
+  /**
+   * Internal flag to indicate the delimiters have been
+   * changed.
+   *
+   * @type {Boolean}
+   */
+
+  _delimitersChanged: true
+
 }
 
+/**
+ * Interpolation delimiters.
+ * We need to mark the changed flag so that the text parser
+ * knows it needs to recompile the regex.
+ *
+ * @type {Array<String>}
+ */
+
+var delimiters = ['{{', '}}']
 Object.defineProperty(module.exports, 'delimiters', {
-    get: function () {
-        return TextParser.delimiters
-    },
-    set: function (delimiters) {
-        TextParser.setDelimiters(delimiters)
-    }
+  get: function () {
+    return delimiters
+  },
+  set: function (val) {
+    delimiters = val
+    this._delimitersChanged = true
+  }
 })
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/deps-parser.js b/vendor/assets/javascripts/bower/vue/src/deps-parser.js
deleted file mode 100644
index 2480336..0000000
--- a/vendor/assets/javascripts/bower/vue/src/deps-parser.js
+++ /dev/null
@@ -1,65 +0,0 @@
-var Emitter  = require('./emitter'),
-    utils    = require('./utils'),
-    Observer = require('./observer'),
-    catcher  = new Emitter()
-
-/**
- *  Auto-extract the dependencies of a computed property
- *  by recording the getters triggered when evaluating it.
- */
-function catchDeps (binding) {
-    if (binding.isFn) return
-    utils.log('\n- ' + binding.key)
-    var got = utils.hash()
-    binding.deps = []
-    catcher.on('get', function (dep) {
-        var has = got[dep.key]
-        if (
-            // avoid duplicate bindings
-            (has && has.compiler === dep.compiler) ||
-            // avoid repeated items as dependency
-            // only when the binding is from self or the parent chain
-            (dep.compiler.repeat && !isParentOf(dep.compiler, binding.compiler))
-        ) {
-            return
-        }
-        got[dep.key] = dep
-        utils.log('  - ' + dep.key)
-        binding.deps.push(dep)
-        dep.subs.push(binding)
-    })
-    binding.value.$get()
-    catcher.off('get')
-}
-
-/**
- *  Test if A is a parent of or equals B
- */
-function isParentOf (a, b) {
-    while (b) {
-        if (a === b) {
-            return true
-        }
-        b = b.parent
-    }
-}
-
-module.exports = {
-
-    /**
-     *  the observer that catches events triggered by getters
-     */
-    catcher: catcher,
-
-    /**
-     *  parse a list of computed property bindings
-     */
-    parse: function (bindings) {
-        utils.log('\nparsing dependencies...')
-        Observer.shouldGet = true
-        bindings.forEach(catchDeps)
-        Observer.shouldGet = false
-        utils.log('\ndone.')
-    }
-    
-}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directive.js b/vendor/assets/javascripts/bower/vue/src/directive.js
index 670a1b2..77effe9 100644
--- a/vendor/assets/javascripts/bower/vue/src/directive.js
+++ b/vendor/assets/javascripts/bower/vue/src/directive.js
@@ -1,258 +1,202 @@
-var dirId           = 1,
-    ARG_RE          = /^[\w\$-]+$/,
-    FILTER_TOKEN_RE = /[^\s'"]+|'[^']+'|"[^"]+"/g,
-    NESTING_RE      = /^\$(parent|root)\./,
-    SINGLE_VAR_RE   = /^[\w\.$]+$/,
-    QUOTE_RE        = /"/g,
-    TextParser      = require('./text-parser')
+var _ = require('./util')
+var config = require('./config')
+var Watcher = require('./watcher')
+var textParser = require('./parse/text')
+var expParser = require('./parse/expression')
 
 /**
- *  Directive class
- *  represents a single directive instance in the DOM
+ * 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 {Function} [linker] - pre-compiled linker function
+ * @constructor
  */
-function Directive (name, ast, definition, compiler, el) {
 
-    this.id             = dirId++
-    this.name           = name
-    this.compiler       = compiler
-    this.vm             = compiler.vm
-    this.el             = el
-    this.computeFilters = false
-    this.key            = ast.key
-    this.arg            = ast.arg
-    this.expression     = ast.expression
+function Directive (name, el, vm, descriptor, def, linker) {
+  // 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._linker = linker
+  this._locked = false
+  this._bound = false
+  // init
+  this._bind(def)
+}
 
-    var isEmpty = this.expression === ''
+var p = Directive.prototype
 
-    // mix in properties from the directive definition
-    if (typeof definition === 'function') {
-        this[isEmpty ? 'bind' : 'update'] = definition
+/**
+ * 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.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.update && this._watcherExp &&
+    (!this.isLiteral || this._isDynamicLiteral) &&
+    !this._checkStatement()
+  ) {
+    // use raw expression as identifier because filters
+    // make them different watchers
+    var watcher = this.vm._watchers[this.raw]
+    // wrapped updater for context
+    var dir = this
+    var update = this._update = function (val, oldVal) {
+      if (!dir._locked) {
+        dir.update(val, oldVal)
+      }
+    }
+    if (!watcher) {
+      watcher = this.vm._watchers[this.raw] = new Watcher(
+        this.vm,
+        this._watcherExp,
+        update, // callback
+        this.filters,
+        this.twoWay // need setter
+      )
     } else {
-        for (var prop in definition) {
-            this[prop] = definition[prop]
-        }
+      watcher.addCb(update)
     }
-
-    // empty expression, we're done.
-    if (isEmpty || this.isEmpty) {
-        this.isEmpty = true
-        return
-    }
-
-    if (TextParser.Regex.test(this.key)) {
-        this.key = compiler.eval(this.key)
-        if (this.isLiteral) {
-            this.expression = this.key
-        }
-    }
-
-    var filters = ast.filters,
-        filter, fn, i, l, computed
-    if (filters) {
-        this.filters = []
-        for (i = 0, l = filters.length; i < l; i++) {
-            filter = filters[i]
-            fn = this.compiler.getOption('filters', filter.name)
-            if (fn) {
-                filter.apply = fn
-                this.filters.push(filter)
-                if (fn.computed) {
-                    computed = true
-                }
-            }
-        }
-    }
-
-    if (!this.filters || !this.filters.length) {
-        this.filters = null
-    }
-
-    if (computed) {
-        this.computedKey = Directive.inlineFilters(this.key, this.filters)
-        this.filters = null
-    }
-
-    this.isExp =
-        computed ||
-        !SINGLE_VAR_RE.test(this.key) ||
-        NESTING_RE.test(this.key)
-
-}
-
-var DirProto = Directive.prototype
-
-/**
- *  called when a new value is set 
- *  for computed properties, this will only be called once
- *  during initialization.
- */
-DirProto.$update = function (value, init) {
-    if (this.$lock) return
-    if (init || value !== this.value || (value && typeof value === 'object')) {
-        this.value = value
-        if (this.update) {
-            this.update(
-                this.filters && !this.computeFilters
-                    ? this.$applyFilters(value)
-                    : value,
-                init
-            )
-        }
+    this._watcher = watcher
+    if (this._initValue != null) {
+      watcher.set(this._initValue)
+    } else {
+      this.update(watcher.value)
     }
+  }
+  this._bound = true
 }
 
 /**
- *  pipe the value through filters
+ * check if this is a dynamic literal binding.
+ *
+ * e.g. v-component="{{currentView}}"
  */
-DirProto.$applyFilters = function (value) {
-    var filtered = value, filter
-    for (var i = 0, l = this.filters.length; i < l; i++) {
-        filter = this.filters[i]
-        filtered = filter.apply.apply(this.vm, [filtered].concat(filter.args))
+
+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 filtered
+  }
 }
 
 /**
- *  Unbind diretive
+ * 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++"
+ *
+ * @return {Boolean}
  */
-DirProto.$unbind = function () {
-    // this can be called before the el is even assigned...
-    if (!this.el || !this.vm) return
-    if (this.unbind) this.unbind()
-    this.vm = this.el = this.binding = this.compiler = null
-}
 
-// Exposed static methods -----------------------------------------------------
-
-/**
- *  Parse a directive string into an Array of
- *  AST-like objects representing directives
- */
-Directive.parse = function (str) {
-
-    var inSingle = false,
-        inDouble = false,
-        curly    = 0,
-        square   = 0,
-        paren    = 0,
-        begin    = 0,
-        argIndex = 0,
-        dirs     = [],
-        dir      = {},
-        lastFilterIndex = 0,
-        arg
-
-    for (var c, i = 0, l = str.length; i < l; i++) {
-        c = str.charAt(i)
-        if (inSingle) {
-            // check single quote
-            if (c === "'") inSingle = !inSingle
-        } else if (inDouble) {
-            // check double quote
-            if (c === '"') inDouble = !inDouble
-        } else if (c === ',' && !paren && !curly && !square) {
-            // reached the end of a directive
-            pushDir()
-            // reset & skip the comma
-            dir = {}
-            begin = argIndex = lastFilterIndex = i + 1
-        } else if (c === ':' && !dir.key && !dir.arg) {
-            // argument
-            arg = str.slice(begin, i).trim()
-            if (ARG_RE.test(arg)) {
-                argIndex = i + 1
-                dir.arg = arg
-            }
-        } else if (c === '|' && str.charAt(i + 1) !== '|' && str.charAt(i - 1) !== '|') {
-            if (dir.key === undefined) {
-                // first filter, end of key
-                lastFilterIndex = i + 1
-                dir.key = str.slice(argIndex, i).trim()
-            } else {
-                // already has filter
-                pushFilter()
-            }
-        } else if (c === '"') {
-            inDouble = true
-        } else if (c === "'") {
-            inSingle = true
-        } else if (c === '(') {
-            paren++
-        } else if (c === ')') {
-            paren--
-        } else if (c === '[') {
-            square++
-        } else if (c === ']') {
-            square--
-        } else if (c === '{') {
-            curly++
-        } else if (c === '}') {
-            curly--
-        }
+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 (i === 0 || begin !== i) {
-        pushDir()
+    if (this.filters) {
+      handler = _.applyFilters(
+        handler,
+        this.filters.read,
+        vm
+      )
     }
-
-    function pushDir () {
-        dir.expression = str.slice(begin, i).trim()
-        if (dir.key === undefined) {
-            dir.key = str.slice(argIndex, i).trim()
-        } else if (lastFilterIndex !== begin) {
-            pushFilter()
-        }
-        if (i === 0 || dir.key) {
-            dirs.push(dir)
-        }
-    }
-
-    function pushFilter () {
-        var exp = str.slice(lastFilterIndex, i).trim(),
-            filter
-        if (exp) {
-            filter = {}
-            var tokens = exp.match(FILTER_TOKEN_RE)
-            filter.name = tokens[0]
-            filter.args = tokens.length > 1 ? tokens.slice(1) : null
-        }
-        if (filter) {
-            (dir.filters = dir.filters || []).push(filter)
-        }
-        lastFilterIndex = i + 1
-    }
-
-    return dirs
+    this.update(handler)
+    return true
+  }
 }
 
 /**
- *  Inline computed filters so they become part
- *  of the expression
+ * Teardown the watcher and call unbind.
  */
-Directive.inlineFilters = function (key, filters) {
-    var args, filter
-    for (var i = 0, l = filters.length; i < l; i++) {
-        filter = filters[i]
-        args = filter.args
-            ? ',"' + filter.args.map(escapeQuote).join('","') + '"'
-            : ''
-        key = 'this.$compiler.getOption("filters", "' +
-                filter.name +
-            '").call(this,' +
-                key + args +
-            ')'
+
+p._teardown = function () {
+  if (this._bound) {
+    if (this.unbind) {
+      this.unbind()
     }
-    return key
+    var watcher = this._watcher
+    if (watcher && watcher.active) {
+      watcher.removeCb(this._update)
+      if (!watcher.active) {
+        this.vm._watchers[this.raw] = null
+      }
+    }
+    this._bound = false
+    this.vm = this.el = this._watcher = null
+  }
 }
 
 /**
- *  Convert double quotes to single quotes
- *  so they don't mess up the generated function body
+ * Set the corresponding value with the setter.
+ * This should only be used in two-way directives
+ * e.g. v-model.
+ *
+ * @param {*} value
+ * @param {Boolean} lock - prevent wrtie triggering update.
+ * @public
  */
-function escapeQuote (v) {
-    return v.indexOf('"') > -1
-        ? v.replace(QUOTE_RE, '\'')
-        : v
+
+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        
+      })
+    }
+  }
 }
 
 module.exports = Directive
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/attr.js b/vendor/assets/javascripts/bower/vue/src/directives/attr.js
new file mode 100644
index 0000000..94c440c
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/attr.js
@@ -0,0 +1,32 @@
+// 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')
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/class.js b/vendor/assets/javascripts/bower/vue/src/directives/class.js
new file mode 100644
index 0000000..a7b5da2
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/class.js
@@ -0,0 +1,18 @@
+var _ = require('../util')
+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
+    }
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/cloak.js b/vendor/assets/javascripts/bower/vue/src/directives/cloak.js
new file mode 100644
index 0000000..88a1df6
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/cloak.js
@@ -0,0 +1,12 @@
+var config = require('../config')
+
+module.exports = {
+
+  bind: function () {
+    var el = this.el
+    this.vm.$once('hook:compiled', function () {
+      el.removeAttribute(config.prefix + 'cloak')
+    })
+  }
+
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/component.js b/vendor/assets/javascripts/bower/vue/src/directives/component.js
new file mode 100644
index 0000000..43d2725
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/component.js
@@ -0,0 +1,156 @@
+var _ = require('../util')
+var templateParser = require('../parse/template')
+
+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
+      this.checkKeepAlive()
+      // check parent directives
+      this.parentLinker = this.el._parentLinker
+      // if static, build right now.
+      if (!this._isDynamicLiteral) {
+        this.resolveCtor(this.expression)
+        this.build()
+      }
+    } else {
+      _.warn(
+        'v-component="' + this.expression + '" cannot be ' +
+        'used on an already mounted instance.'
+      )
+    }
+  },
+
+  /**
+   * Check if the "keep-alive" flag is present.
+   * 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.
+   */
+
+  checkKeepAlive: function () {
+    // check keep-alive flag
+    this.keepAlive = this.el.hasAttribute('keep-alive')
+    if (this.keepAlive) {
+      this.el.removeAttribute('keep-alive')
+      this.cache = {}
+    }
+  },
+
+  /**
+   * Resolve the component constructor to use when creating
+   * the child vm.
+   */
+
+  resolveCtor: function (id) {
+    this.ctorId = id
+    this.Ctor = this.vm.$options.components[id]
+    _.assertAsset(this.Ctor, 'component', id)
+  },
+
+  /**
+   * Instantiate/insert a new child vm.
+   * If keep alive and has cached instance, insert that
+   * instance; otherwise build a new one and cache it.
+   */
+
+  build: function () {
+    if (this.keepAlive) {
+      var cached = this.cache[this.ctorId]
+      if (cached) {
+        this.childVM = cached
+        cached.$before(this.ref)
+        return
+      }
+    }
+    var vm = this.vm
+    if (this.Ctor && !this.childVM) {
+      this.childVM = vm.$addChild({
+        el: templateParser.clone(this.el)
+      }, this.Ctor)
+      if (this.parentLinker) {
+        var dirCount = vm._directives.length
+        var targetVM = this.childVM.$options.inherit
+          ? this.childVM
+          : vm
+        this.parentLinker(targetVM, this.childVM.$el)
+        this.parentDirs = vm._directives.slice(dirCount)
+      }
+      if (this.keepAlive) {
+        this.cache[this.ctorId] = this.childVM
+      }
+      this.childVM.$before(this.ref)
+    }
+  },
+
+  /**
+   * Teardown the active vm.
+   * If keep alive, simply remove it; otherwise destroy it.
+   *
+   * @param {Boolean} remove
+   */
+
+  unbuild: function (remove) {
+    var child = this.childVM
+    if (!child) {
+      return
+    }
+    if (this.keepAlive) {
+      if (remove) {
+        child.$remove()
+      }
+    } else {
+      child.$destroy(remove)
+      var parentDirs = this.parentDirs
+      if (parentDirs) {
+        var i = parentDirs.length
+        while (i--) {
+          parentDirs[i]._teardown()
+        }
+      }
+    }
+    this.childVM = null
+  },
+
+  /**
+   * Update callback for the dynamic literal scenario,
+   * e.g. v-component="{{view}}"
+   */
+
+  update: function (value) {
+    this.unbuild(true)
+    if (value) {
+      this.resolveCtor(value)
+      this.build()
+    }
+  },
+
+  /**
+   * Unbind.
+   * Make sure keepAlive is set to false so that the
+   * instance is always destroyed.
+   */
+
+  unbind: function () {
+    this.keepAlive = false
+    this.unbuild()
+  }
+
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/el.js b/vendor/assets/javascripts/bower/vue/src/directives/el.js
new file mode 100644
index 0000000..9ba6e19
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/el.js
@@ -0,0 +1,13 @@
+module.exports = {
+
+  isLiteral: true,
+
+  bind: function () {
+    this.vm.$$[this.expression] = this.el
+  },
+
+  unbind: function () {
+    delete this.vm.$$[this.expression]
+  }
+  
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/html.js b/vendor/assets/javascripts/bower/vue/src/directives/html.js
index 028a31b..11e1f55 100644
--- a/vendor/assets/javascripts/bower/vue/src/directives/html.js
+++ b/vendor/assets/javascripts/bower/vue/src/directives/html.js
@@ -1,41 +1,37 @@
-var utils = require('../utils'),
-    slice = [].slice
+var _ = require('../util')
+var templateParser = require('../parse/template')
 
-/**
- *  Binding for innerHTML
- */
 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 = []
-        }
-    },
-
-    update: function (value) {
-        value = utils.guard(value)
-        if (this.nodes) {
-            this.swap(value)
-        } else {
-            this.el.innerHTML = value
-        }
-    },
-
-    swap: function (value) {
-        var parent = this.el.parentNode,
-            nodes  = this.nodes,
-            i      = nodes.length
-        // remove old nodes
-        while (i--) {
-            parent.removeChild(nodes[i])
-        }
-        // convert new value to a fragment
-        var frag = utils.toFragment(value)
-        // save a reference to these nodes so we can remove later
-        this.nodes = slice.call(frag.childNodes)
-        parent.insertBefore(frag, this.el)
+  bind: function () {
+    // a comment node means this is a binding for
+    // {{{ inline unescaped html }}}
+    if (this.el.nodeType === 8) {
+      // hold nodes
+      this.nodes = []
     }
+  },
+
+  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
+    var frag = templateParser.parse(value, true)
+    // save a reference to these nodes so we can remove later
+    this.nodes = _.toArray(frag.childNodes)
+    _.before(frag, this.el)
+  }
+
 }
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/if.js b/vendor/assets/javascripts/bower/vue/src/directives/if.js
index 387ff29..f9ae2bb 100644
--- a/vendor/assets/javascripts/bower/vue/src/directives/if.js
+++ b/vendor/assets/javascripts/bower/vue/src/directives/if.js
@@ -1,56 +1,68 @@
-var utils    = require('../utils')
+var _ = require('../util')
+var compile = require('../compile/compile')
+var templateParser = require('../parse/template')
+var transition = require('../transition')
 
-/**
- *  Manages a conditional child VM
- */
 module.exports = {
 
-    bind: function () {
-        
-        this.parent = this.el.parentNode
-        this.ref    = document.createComment('vue-if')
-        this.Ctor   = this.compiler.resolveComponent(this.el)
-
-        // insert ref
-        this.parent.insertBefore(this.ref, this.el)
-        this.parent.removeChild(this.el)
-
-        if (utils.attr(this.el, 'view')) {
-            utils.warn(
-                'Conflict: v-if cannot be used together with v-view. ' +
-                'Just set v-view\'s binding value to empty string to empty it.'
-            )
-        }
-        if (utils.attr(this.el, 'repeat')) {
-            utils.warn(
-                'Conflict: v-if cannot be used together with v-repeat. ' +
-                'Use `v-show` or the `filterBy` filter instead.'
-            )
-        }
-    },
-
-    update: function (value) {
-
-        if (!value) {
-            this.unbind()
-        } else if (!this.childVM) {
-            this.childVM = new this.Ctor({
-                el: this.el.cloneNode(true),
-                parent: this.vm
-            })
-            if (this.compiler.init) {
-                this.parent.insertBefore(this.childVM.$el, this.ref)
-            } else {
-                this.childVM.$before(this.ref)
-            }
-        }
-        
-    },
-
-    unbind: function () {
-        if (this.childVM) {
-            this.childVM.$destroy()
-            this.childVM = null
-        }
+  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(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) {
+      this.insert()
+    } else {
+      this.teardown()
+    }
+  },
+
+  insert: function () {
+    // avoid duplicate inserts, since update() can be
+    // called with different truthy values
+    if (this.decompile) {
+      return
+    }
+    var vm = this.vm
+    var frag = templateParser.clone(this.template)
+    var decompile = this.linker(vm, frag)
+    this.decompile = function () {
+      decompile()
+      transition.blockRemove(this.start, this.end, vm)
+    }
+    transition.blockAppend(frag, this.end, vm)
+  },
+
+  teardown: function () {
+    if (this.decompile) {
+      this.decompile()
+      this.decompile = null
+    }
+  }
+
 }
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/index.js b/vendor/assets/javascripts/bower/vue/src/directives/index.js
index cd8ab83..11d58fa 100644
--- a/vendor/assets/javascripts/bower/vue/src/directives/index.js
+++ b/vendor/assets/javascripts/bower/vue/src/directives/index.js
@@ -1,129 +1,22 @@
-var utils      = require('../utils'),
-    config     = require('../config'),
-    transition = require('../transition'),
-    directives = module.exports = utils.hash()
+// manipulation directives
+exports.text       = require('./text')
+exports.html       = require('./html')
+exports.attr       = require('./attr')
+exports.show       = require('./show')
+exports['class']   = require('./class')
+exports.el         = require('./el')
+exports.ref        = require('./ref')
+exports.cloak      = require('./cloak')
+exports.style      = require('./style')
+exports.partial    = require('./partial')
+exports.transition = require('./transition')
 
-/**
- *  Nest and manage a Child VM
- */
-directives.component = {
-    isLiteral: true,
-    bind: function () {
-        if (!this.el.vue_vm) {
-            this.childVM = new this.Ctor({
-                el: this.el,
-                parent: this.vm
-            })
-        }
-    },
-    unbind: function () {
-        if (this.childVM) {
-            this.childVM.$destroy()
-        }
-    }
-}
+// event listener directives
+exports.on         = require('./on')
+exports.model      = require('./model')
 
-/**
- *  Binding HTML attributes
- */
-directives.attr = {
-    bind: function () {
-        var params = this.vm.$options.paramAttributes
-        this.isParam = params && params.indexOf(this.arg) > -1
-    },
-    update: function (value) {
-        if (value || value === 0) {
-            this.el.setAttribute(this.arg, value)
-        } else {
-            this.el.removeAttribute(this.arg)
-        }
-        if (this.isParam) {
-            this.vm[this.arg] = utils.checkNumber(value)
-        }
-    }
-}
-
-/**
- *  Binding textContent
- */
-directives.text = {
-    bind: function () {
-        this.attr = this.el.nodeType === 3
-            ? 'nodeValue'
-            : 'textContent'
-    },
-    update: function (value) {
-        this.el[this.attr] = utils.guard(value)
-    }
-}
-
-/**
- *  Binding CSS display property
- */
-directives.show = function (value) {
-    var el = this.el,
-        target = value ? '' : 'none',
-        change = function () {
-            el.style.display = target
-        }
-    transition(el, value ? 1 : -1, change, this.compiler)
-}
-
-/**
- *  Binding CSS classes
- */
-directives['class'] = function (value) {
-    if (this.arg) {
-        utils[value ? 'addClass' : 'removeClass'](this.el, this.arg)
-    } else {
-        if (this.lastVal) {
-            utils.removeClass(this.el, this.lastVal)
-        }
-        if (value) {
-            utils.addClass(this.el, value)
-            this.lastVal = value
-        }
-    }
-}
-
-/**
- *  Only removed after the owner VM is ready
- */
-directives.cloak = {
-    isEmpty: true,
-    bind: function () {
-        var el = this.el
-        this.compiler.observer.once('hook:ready', function () {
-            el.removeAttribute(config.prefix + '-cloak')
-        })
-    }
-}
-
-/**
- *  Store a reference to self in parent VM's $
- */
-directives.ref = {
-    isLiteral: true,
-    bind: function () {
-        var id = this.expression
-        if (id) {
-            this.vm.$parent.$[id] = this.vm
-        }
-    },
-    unbind: function () {
-        var id = this.expression
-        if (id) {
-            delete this.vm.$parent.$[id]
-        }
-    }
-}
-
-directives.on      = require('./on')
-directives.repeat  = require('./repeat')
-directives.model   = require('./model')
-directives['if']   = require('./if')
-directives['with'] = require('./with')
-directives.html    = require('./html')
-directives.style   = require('./style')
-directives.partial = require('./partial')
-directives.view    = require('./view')
\ No newline at end of file
+// child vm directives
+exports.component  = require('./component')
+exports.repeat     = require('./repeat')
+exports['if']      = require('./if')
+exports['with']    = require('./with')
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/model.js b/vendor/assets/javascripts/bower/vue/src/directives/model.js
deleted file mode 100644
index 2946ce6..0000000
--- a/vendor/assets/javascripts/bower/vue/src/directives/model.js
+++ /dev/null
@@ -1,174 +0,0 @@
-var utils = require('../utils'),
-    isIE9 = navigator.userAgent.indexOf('MSIE 9.0') > 0,
-    filter = [].filter
-
-/**
- *  Returns an array of values from a multiple select
- */
-function getMultipleSelectOptions (select) {
-    return filter
-        .call(select.options, function (option) {
-            return option.selected
-        })
-        .map(function (option) {
-            return option.value || option.text
-        })
-}
-
-/**
- *  Two-way binding for form input elements
- */
-module.exports = {
-
-    bind: function () {
-
-        var self = this,
-            el   = self.el,
-            type = el.type,
-            tag  = el.tagName
-
-        self.lock = false
-        self.ownerVM = self.binding.compiler.vm
-
-        // determine what event to listen to
-        self.event =
-            (self.compiler.options.lazy ||
-            tag === 'SELECT' ||
-            type === 'checkbox' || type === 'radio')
-                ? 'change'
-                : 'input'
-
-        // determine the attribute to change when updating
-        self.attr = type === 'checkbox'
-            ? 'checked'
-            : (tag === 'INPUT' || tag === 'SELECT' || tag === 'TEXTAREA')
-                ? 'value'
-                : 'innerHTML'
-
-        // select[multiple] support
-        if(tag === 'SELECT' && el.hasAttribute('multiple')) {
-            this.multi = true
-        }
-
-        var compositionLock = false
-        self.cLock = function () {
-            compositionLock = true
-        }
-        self.cUnlock = function () {
-            compositionLock = false
-        }
-        el.addEventListener('compositionstart', this.cLock)
-        el.addEventListener('compositionend', this.cUnlock)
-
-        // attach listener
-        self.set = self.filters
-            ? function () {
-                if (compositionLock) return
-                // if this directive has filters
-                // we need to let the vm.$set trigger
-                // update() so filters are applied.
-                // therefore we have to record cursor position
-                // so that after vm.$set changes the input
-                // value we can put the cursor back at where it is
-                var cursorPos
-                try { cursorPos = el.selectionStart } catch (e) {}
-
-                self._set()
-
-                // since updates are async
-                // we need to reset cursor position async too
-                utils.nextTick(function () {
-                    if (cursorPos !== undefined) {
-                        el.setSelectionRange(cursorPos, cursorPos)
-                    }
-                })
-            }
-            : function () {
-                if (compositionLock) return
-                // no filters, don't let it trigger update()
-                self.lock = true
-
-                self._set()
-
-                utils.nextTick(function () {
-                    self.lock = false
-                })
-            }
-        el.addEventListener(self.event, self.set)
-
-        // fix shit for IE9
-        // since it doesn't fire input on backspace / del / cut
-        if (isIE9) {
-            self.onCut = function () {
-                // cut event fires before the value actually changes
-                utils.nextTick(function () {
-                    self.set()
-                })
-            }
-            self.onDel = function (e) {
-                if (e.keyCode === 46 || e.keyCode === 8) {
-                    self.set()
-                }
-            }
-            el.addEventListener('cut', self.onCut)
-            el.addEventListener('keyup', self.onDel)
-        }
-    },
-
-    _set: function () {
-        this.ownerVM.$set(
-            this.key, this.multi
-                ? getMultipleSelectOptions(this.el)
-                : this.el[this.attr]
-        )
-    },
-
-    update: function (value, init) {
-        /* jshint eqeqeq: false */
-        // sync back inline value if initial data is undefined
-        if (init && value === undefined) {
-            return this._set()
-        }
-        if (this.lock) return
-        var el = this.el
-        if (el.tagName === 'SELECT') { // select dropdown
-            el.selectedIndex = -1
-            if(this.multi && Array.isArray(value)) {
-                value.forEach(this.updateSelect, this)
-            } else {
-                this.updateSelect(value)
-            }
-        } else if (el.type === 'radio') { // radio button
-            el.checked = value == el.value
-        } else if (el.type === 'checkbox') { // checkbox
-            el.checked = !!value
-        } else {
-            el[this.attr] = utils.guard(value)
-        }
-    },
-
-    updateSelect: function (value) {
-        /* jshint eqeqeq: false */
-        // setting <select>'s value in IE9 doesn't work
-        // we have to manually loop through the options
-        var options = this.el.options,
-            i = options.length
-        while (i--) {
-            if (options[i].value == value) {
-                options[i].selected = true
-                break
-            }
-        }
-    },
-
-    unbind: function () {
-        var el = this.el
-        el.removeEventListener(this.event, this.set)
-        el.removeEventListener('compositionstart', this.cLock)
-        el.removeEventListener('compositionend', this.cUnlock)
-        if (isIE9) {
-            el.removeEventListener('cut', this.onCut)
-            el.removeEventListener('keyup', this.onDel)
-        }
-    }
-}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/model/checkbox.js b/vendor/assets/javascripts/bower/vue/src/directives/model/checkbox.js
new file mode 100644
index 0000000..450b31e
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/model/checkbox.js
@@ -0,0 +1,25 @@
+var _ = require('../../util')
+
+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
+    }
+  },
+
+  update: function (value) {
+    this.el.checked = !!value
+  },
+
+  unbind: function () {
+    _.off(this.el, 'change', this.listener)
+  }
+
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/model/default.js b/vendor/assets/javascripts/bower/vue/src/directives/model/default.js
new file mode 100644
index 0000000..23c854a
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/model/default.js
@@ -0,0 +1,117 @@
+var _ = require('../../util')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+
+    // check params
+    // - lazy: update model on "change" instead of "input"
+    var lazy = el.hasAttribute('lazy')
+    if (lazy) {
+      el.removeAttribute('lazy')
+    }
+    // - number: cast value into number when updating model.
+    var number =
+      el.hasAttribute('number') ||
+      el.type === 'number'
+    if (number) {
+      el.removeAttribute('number')
+    }
+
+    // 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.
+    this.listener = 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) {}
+      set()
+      // 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.
+      _.nextTick(function () {
+        var newVal = self._watcher.value
+        self.update(newVal)
+        if (charsOffset != null) {
+          var cursorPos =
+            _.toString(newVal).length - charsOffset
+          el.setSelectionRange(cursorPos, cursorPos)
+        }
+      })
+    }
+    this.event = lazy ? 'change' : 'input'
+    _.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
+    }
+  },
+
+  update: function (value) {
+    this.el.value = _.toString(value)
+  },
+
+  unbind: function () {
+    var el = this.el
+    _.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)
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/model/index.js b/vendor/assets/javascripts/bower/vue/src/directives/model/index.js
new file mode 100644
index 0000000..5380f41
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/model/index.js
@@ -0,0 +1,56 @@
+var _ = require('../../util')
+
+var handlers = {
+  _default: require('./default'),
+  radio: require('./radio'),
+  select: require('./select'),
+  checkbox: require('./checkbox')
+}
+
+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
+    }
+    handler.bind.call(this)
+    this.update = handler.update
+    this.unbind = handler.unbind
+  }
+
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/model/radio.js b/vendor/assets/javascripts/bower/vue/src/directives/model/radio.js
new file mode 100644
index 0000000..99e881d
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/model/radio.js
@@ -0,0 +1,26 @@
+var _ = require('../../util')
+
+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)
+  }
+
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/model/select.js b/vendor/assets/javascripts/bower/vue/src/directives/model/select.js
new file mode 100644
index 0000000..e7264fc
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/model/select.js
@@ -0,0 +1,167 @@
+var _ = require('../../util')
+var Watcher = require('../../watcher')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+    // check options param
+    var optionsParam = el.getAttribute('options')
+    if (optionsParam) {
+      el.removeAttribute('options')
+      initOptions.call(this, optionsParam)
+    }
+    this.multiple = el.hasAttribute('multiple')
+    this.listener = function () {
+      var value = self.multiple
+        ? getMultiValue(el)
+        : el.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()
+    }
+  }
+
+}
+
+/**
+ * Initialize the option list from the param.
+ *
+ * @param {String} expression
+ */
+
+function initOptions (expression) {
+  var self = this
+  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)
+    }
+  }
+  this.optionWatcher = new Watcher(
+    this.vm,
+    expression,
+    optionUpdateWatcher
+  )
+  // update with initial value
+  optionUpdateWatcher(this.optionWatcher.value)
+}
+
+/**
+ * Build up option elements. IE9 doesn't create options
+ * when setting innerHTML on <select> elements, so we have
+ * to use DOM API here.
+ *
+ * @param {Element} parent - a <select> or an <optgroup>
+ * @param {Array} options
+ */
+
+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)
+    }
+    parent.appendChild(el)
+  }
+}
+
+/**
+ * Check the initial value for selected options.
+ */
+
+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 (initValue) {
+    this._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
+}
+
+function getOptionValue (op) {
+  return op.value || op.text
+}
+
+/**
+ * Native Array.indexOf uses strict equal, but in this
+ * case we need to match string/numbers with soft equal.
+ *
+ * @param {Array} arr
+ * @param {*} val
+ */
+
+function indexOf (arr, val) {
+  /* jshint eqeqeq: false */
+  var i = arr.length
+  while (i--) {
+    if (arr[i] == val) return i
+  }
+  return -1
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/on.js b/vendor/assets/javascripts/bower/vue/src/directives/on.js
index 16fa16a..217e244 100644
--- a/vendor/assets/javascripts/bower/vue/src/directives/on.js
+++ b/vendor/assets/javascripts/bower/vue/src/directives/on.js
@@ -1,58 +1,59 @@
-var utils    = require('../utils')
+var _ = require('../util')
 
-/**
- *  Binding for event listeners
- */
 module.exports = {
 
-    isFn: true,
+  acceptStatement: true,
+  priority: 700,
 
-    bind: function () {
-        this.context = this.binding.isExp
-            ? this.vm
-            : this.binding.compiler.vm
-        if (this.el.tagName === 'IFRAME' && this.arg !== 'load') {
-            var self = this
-            this.iframeBind = function () {
-                self.el.contentWindow.addEventListener(self.arg, self.handler)
-            }
-            this.el.addEventListener('load', this.iframeBind)
-        }
-    },
-
-    update: function (handler) {
-        if (typeof handler !== 'function') {
-            utils.warn('Directive "v-on:' + this.expression + '" expects a method.')
-            return
-        }
-        this.reset()
-        var vm = this.vm,
-            context = this.context
-        this.handler = function (e) {
-            e.targetVM = vm
-            context.$event = e
-            var res = handler.call(context, e)
-            context.$event = null
-            return res
-        }
-        if (this.iframeBind) {
-            this.iframeBind()
-        } else {
-            this.el.addEventListener(this.arg, this.handler)
-        }
-    },
-
-    reset: function () {
-        var el = this.iframeBind
-            ? this.el.contentWindow
-            : this.el
-        if (this.handler) {
-            el.removeEventListener(this.arg, this.handler)
-        }
-    },
-
-    unbind: function () {
-        this.reset()
-        this.el.removeEventListener('load', this.iframeBind)
+  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)
+  }
 }
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/partial.js b/vendor/assets/javascripts/bower/vue/src/directives/partial.js
index 4086742..c1fb20c 100644
--- a/vendor/assets/javascripts/bower/vue/src/directives/partial.js
+++ b/vendor/assets/javascripts/bower/vue/src/directives/partial.js
@@ -1,50 +1,55 @@
-var utils = require('../utils')
+var _ = require('../util')
+var templateParser = require('../parse/template')
+var transition = require('../transition')
 
-/**
- *  Binding for partials
- */
 module.exports = {
 
-    isLiteral: true,
+  isLiteral: true,
 
-    bind: function () {
-
-        var id = this.expression
-        if (!id) return
-
-        var el       = this.el,
-            compiler = this.compiler,
-            partial  = compiler.getOption('partials', id)
-
-        if (!partial) {
-            if (id === 'yield') {
-                utils.warn('{{>yield}} syntax has been deprecated. Use <content> tag instead.')
-            }
-            return
-        }
-
-        partial = partial.cloneNode(true)
-
-        // comment ref node means inline partial
-        if (el.nodeType === 8) {
-
-            // keep a ref for the partial's content nodes
-            var nodes = [].slice.call(partial.childNodes),
-                parent = el.parentNode
-            parent.insertBefore(partial, el)
-            parent.removeChild(el)
-            // compile partial after appending, because its children's parentNode
-            // will change from the fragment to the correct parentNode.
-            // This could affect directives that need access to its element's parentNode.
-            nodes.forEach(compiler.compile, compiler)
-
-        } else {
-
-            // just set innerHTML...
-            el.innerHTML = ''
-            el.appendChild(partial)
-
-        }
+  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.compile(this.expression)
+    }
+  },
+
+  update: function (id) {
+    this.teardown()
+    this.compile(id)
+  },
+
+  compile: function (id) {
+    var partial = this.vm.$options.partials[id]
+    _.assertAsset(partial, 'partial', id)
+    if (!partial) {
+      return
+    }
+    var vm = this.vm
+    var frag = templateParser.parse(partial, true)
+    var decompile = vm.$compile(frag)
+    this.decompile = function () {
+      decompile()
+      transition.blockRemove(this.start, this.end, vm)
+    }
+    transition.blockAppend(frag, this.end, vm)
+  },
+
+  teardown: function () {
+    if (this.decompile) {
+      this.decompile()
+      this.decompile = null
+    }
+  }
 
 }
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/ref.js b/vendor/assets/javascripts/bower/vue/src/directives/ref.js
new file mode 100644
index 0000000..9105de6
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/ref.js
@@ -0,0 +1,24 @@
+var _ = require('../util')
+
+module.exports = {
+
+  isLiteral: true,
+
+  bind: function () {
+    if (this.el !== this.vm.$el) {
+      _.warn(
+        'v-ref should only be used on instance root nodes.'
+      )
+      return
+    }
+    this.owner = this.vm.$parent
+    this.owner.$[this.expression] = this.vm
+  },
+
+  unbind: function () {
+    if (this.owner.$[this.expression] === this.vm) {
+      delete this.owner.$[this.expression]
+    }
+  }
+  
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/repeat.js b/vendor/assets/javascripts/bower/vue/src/directives/repeat.js
index 6994ce8..bbf3e3b 100644
--- a/vendor/assets/javascripts/bower/vue/src/directives/repeat.js
+++ b/vendor/assets/javascripts/bower/vue/src/directives/repeat.js
@@ -1,246 +1,507 @@
-var utils      = require('../utils'),
-    config     = require('../config')
+var _ = require('../util')
+var isObject = _.isObject
+var textParser = require('../parse/text')
+var expParser = require('../parse/expression')
+var templateParser = require('../parse/template')
+var compile = require('../compile/compile')
+var transclude = require('../compile/transclude')
+var mergeOptions = require('../util/merge-option')
+var uid = 0
 
-/**
- *  Binding that manages VMs based on an Array
- */
 module.exports = {
 
-    bind: function () {
+  /**
+   * Setup.
+   */
 
-        this.identifier = '$r' + this.id
-
-        // a hash to cache the same expressions on repeated instances
-        // so they don't have to be compiled for every single instance
-        this.expCache = utils.hash()
-
-        var el   = this.el,
-            ctn  = this.container = el.parentNode
-
-        // extract child Id, if any
-        this.childId = this.compiler.eval(utils.attr(el, 'ref'))
-
-        // create a comment node as a reference node for DOM insertions
-        this.ref = document.createComment(config.prefix + '-repeat-' + this.key)
-        ctn.insertBefore(this.ref, el)
-        ctn.removeChild(el)
-
-        this.collection = null
-        this.vms = null
-
-    },
-
-    update: function (collection) {
-
-        if (!Array.isArray(collection)) {
-            if (utils.isObject(collection)) {
-                collection = utils.objectToArray(collection)
-            } else {
-                utils.warn('v-repeat only accepts Array or Object values.')
-            }
-        }
-
-        // keep reference of old data and VMs
-        // so we can reuse them if possible
-        this.oldVMs = this.vms
-        this.oldCollection = this.collection
-        collection = this.collection = collection || []
-
-        var isObject = collection[0] && utils.isObject(collection[0])
-        this.vms = this.oldCollection
-            ? this.diff(collection, isObject)
-            : this.init(collection, isObject)
-
-        if (this.childId) {
-            this.vm.$[this.childId] = this.vms
-        }
-
-    },
-
-    init: function (collection, isObject) {
-        var vm, vms = []
-        for (var i = 0, l = collection.length; i < l; i++) {
-            vm = this.build(collection[i], i, isObject)
-            vms.push(vm)
-            if (this.compiler.init) {
-                this.container.insertBefore(vm.$el, this.ref)
-            } else {
-                vm.$before(this.ref)
-            }
-        }
-        return vms
-    },
-
-    /**
-     *  Diff the new array with the old
-     *  and determine the minimum amount of DOM manipulations.
-     */
-    diff: function (newCollection, isObject) {
-
-        var i, l, item, vm,
-            oldIndex,
-            targetNext,
-            currentNext,
-            nextEl,
-            ctn    = this.container,
-            oldVMs = this.oldVMs,
-            vms    = []
-
-        vms.length = newCollection.length
-
-        // first pass, collect new reused and new created
-        for (i = 0, l = newCollection.length; i < l; i++) {
-            item = newCollection[i]
-            if (isObject) {
-                item.$index = i
-                if (item.__emitter__ && item.__emitter__[this.identifier]) {
-                    // this piece of data is being reused.
-                    // record its final position in reused vms
-                    item.$reused = true
-                } else {
-                    vms[i] = this.build(item, i, isObject)
-                }
-            } else {
-                // we can't attach an identifier to primitive values
-                // so have to do an indexOf...
-                oldIndex = indexOf(oldVMs, item)
-                if (oldIndex > -1) {
-                    // record the position on the existing vm
-                    oldVMs[oldIndex].$reused = true
-                    oldVMs[oldIndex].$data.$index = i
-                } else {
-                    vms[i] = this.build(item, i, isObject)
-                }
-            }
-        }
-
-        // second pass, collect old reused and destroy unused
-        for (i = 0, l = oldVMs.length; i < l; i++) {
-            vm = oldVMs[i]
-            item = this.arg
-                ? vm.$data[this.arg]
-                : vm.$data
-            if (item.$reused) {
-                vm.$reused = true
-                delete item.$reused
-            }
-            if (vm.$reused) {
-                // update the index to latest
-                vm.$index = item.$index
-                // the item could have had a new key
-                if (item.$key && item.$key !== vm.$key) {
-                    vm.$key = item.$key
-                }
-                vms[vm.$index] = vm
-            } else {
-                // this one can be destroyed.
-                if (item.__emitter__) {
-                    delete item.__emitter__[this.identifier]
-                }
-                vm.$destroy()
-            }
-        }
-
-        // final pass, move/insert DOM elements
-        i = vms.length
-        while (i--) {
-            vm = vms[i]
-            item = vm.$data
-            targetNext = vms[i + 1]
-            if (vm.$reused) {
-                nextEl = vm.$el.nextSibling
-                // destroyed VMs' element might still be in the DOM
-                // due to transitions
-                while (!nextEl.vue_vm && nextEl !== this.ref) {
-                    nextEl = nextEl.nextSibling
-                }
-                currentNext = nextEl.vue_vm
-                if (currentNext !== targetNext) {
-                    if (!targetNext) {
-                        ctn.insertBefore(vm.$el, this.ref)
-                    } else {
-                        nextEl = targetNext.$el
-                        // new VMs' element might not be in the DOM yet
-                        // due to transitions
-                        while (!nextEl.parentNode) {
-                            targetNext = vms[nextEl.vue_vm.$index + 1]
-                            nextEl = targetNext
-                                ? targetNext.$el
-                                : this.ref
-                        }
-                        ctn.insertBefore(vm.$el, nextEl)
-                    }
-                }
-                delete vm.$reused
-                delete item.$index
-                delete item.$key
-            } else { // a new vm
-                vm.$before(targetNext ? targetNext.$el : this.ref)
-            }
-        }
-
-        return vms
-    },
-
-    build: function (data, index, isObject) {
-
-        // wrap non-object values
-        var raw, alias,
-            wrap = !isObject || this.arg
-        if (wrap) {
-            raw = data
-            alias = this.arg || '$value'
-            data = {}
-            data[alias] = raw
-        }
-        data.$index = index
-
-        var el = this.el.cloneNode(true),
-            Ctor = this.compiler.resolveComponent(el, data),
-            vm = new Ctor({
-                el: el,
-                data: data,
-                parent: this.vm,
-                compilerOptions: {
-                    repeat: true,
-                    expCache: this.expCache
-                }
-            })
-
-        if (isObject) {
-            // attach an ienumerable identifier to the raw data
-            (raw || data).__emitter__[this.identifier] = true
-        }
-
-        return vm
-
-    },
-
-    unbind: function () {
-        if (this.childId) {
-            delete this.vm.$[this.childId]
-        }
-        if (this.vms) {
-            var i = this.vms.length
-            while (i--) {
-                this.vms[i].$destroy()
-            }
-        }
+  bind: function () {
+    // uid as a cache identifier
+    this.id = '__v_repeat_' + (++uid)
+    // we need to insert the objToArray converter
+    // as the first read filter.
+    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)
+    // check if this is a block repeat
+    this.template = this.el.tagName === 'TEMPLATE'
+      ? templateParser.parse(this.el, true)
+      : this.el
+    // check other directives that need to be handled
+    // at v-repeat level
+    this.checkIf()
+    this.checkRef()
+    this.checkTrackById()
+    this.checkComponent()
+    // cache for primitive value instances
+    this.cache = Object.create(null)
+  },
+
+  /**
+   * Warn against v-if usage.
+   */
+
+  checkIf: function () {
+    if (_.attr(this.el, 'if') !== null) {
+      _.warn(
+        'Don\'t use v-if with v-repeat. ' +
+        'Use v-show or the "filterBy" filter instead.'
+      )
+    }
+  },
+
+  /**
+   * Check if v-ref/ v-el is also present.
+   */
+
+  checkRef: function () {
+    var childId = _.attr(this.el, 'ref')
+    this.childId = childId
+      ? this.vm.$interpolate(childId)
+      : null
+    var elId = _.attr(this.el, 'el')
+    this.elId = elId
+      ? this.vm.$interpolate(elId)
+      : null
+  },
+
+  /**
+   * Check for a track-by ID, which allows us to identify
+   * a piece of data and its associated instance by its
+   * unique id.
+   */
+
+  checkTrackById: function () {
+    this.idKey = this.el.getAttribute('trackby')
+    if (this.idKey !== null) {
+      this.el.removeAttribute('trackby')
+    }
+  },
+
+  /**
+   * 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')
+    var options = this.vm.$options
+    if (!id) {
+      this.Ctor = _.Vue // default constructor
+      this.inherit = true // inline repeats should inherit
+      // important: transclude with no options, just
+      // to ensure block start and block end
+      this.template = transclude(this.template)
+      this._linker = compile(this.template, options)
+    } else {
+      var tokens = textParser.parse(id)
+      if (!tokens) { // static component
+        var Ctor = this.Ctor = options.components[id]
+        _.assertAsset(Ctor, 'component', id)
+        if (Ctor) {
+          // merge an empty object with owner vm as parent
+          // so child vms can access parent assets.
+          var merged = mergeOptions(
+            Ctor.options,
+            {},
+            { $parent: this.vm }
+          )
+          this.template = transclude(this.template, merged)
+          this._linker = compile(this.template, merged)
+        }
+      } else {
+        // to be resolved later
+        var ctorExp = textParser.tokensToExp(tokens)
+        this.ctorGetter = expParser.parse(ctorExp).get
+      }
+    }
+  },
+
+  /**
+   * Update.
+   * This is called whenever the Array mutates.
+   *
+   * @param {Array} data
+   */
+
+  update: function (data) {
+    if (typeof data === 'number') {
+      data = range(data)
+    }
+    this.vms = this.diff(data || [], this.vms)
+    // update v-ref
+    if (this.childId) {
+      this.vm.$[this.childId] = this.vms
+    }
+    if (this.elId) {
+      this.vm.$$[this.elId] = this.vms.map(function (vm) {
+        return vm.$el
+      })
+    }
+  },
+
+  /**
+   * Diff, based on new data and old data, determine the
+   * minimum amount of DOM manipulations needed to make the
+   * DOM reflect the new data Array.
+   *
+   * The algorithm diffs the new data Array by storing a
+   * hidden reference to an owner vm instance on previously
+   * seen data. This allows us to achieve O(n) which is
+   * better than a levenshtein distance based algorithm,
+   * which is O(m * n).
+   *
+   * @param {Array} data
+   * @param {Array} oldVms
+   * @return {Array}
+   */
+
+  diff: function (data, oldVms) {
+    var idKey = this.idKey
+    var converted = this.converted
+    var ref = this.ref
+    var alias = this.arg
+    var init = !oldVms
+    var vms = new Array(data.length)
+    var obj, raw, vm, i, l
+    // First pass, go through the new Array and fill up
+    // the new vms array. If a piece of data has a cached
+    // instance for it, we reuse it. Otherwise build a new
+    // instance.
+    for (i = 0, l = data.length; i < l; i++) {
+      obj = data[i]
+      raw = converted ? obj.value : obj
+      vm = !init && this.getVm(raw)
+      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
+          if (alias) {
+            vm[alias] = raw
+          } else {
+            vm._setData(raw)
+          }
+        }
+      } else { // new instance
+        vm = this.build(obj, i)
+        vm._new = true
+      }
+      vms[i] = vm
+      // insert if this is first run
+      if (init) {
+        vm.$before(ref)
+      }
+    }
+    // if this is the first run, we're done.
+    if (init) {
+      return vms
+    }
+    // Second pass, go through the old vm instances and
+    // destroy those who are not reused (and remove them
+    // from cache)
+    for (i = 0, l = oldVms.length; i < l; i++) {
+      vm = oldVms[i]
+      if (!vm._reused) {
+        this.uncacheVm(vm)
+        vm.$destroy(true)
+      }
+    }
+    // final pass, move/insert new instances into the
+    // right place. We're going in reverse here because
+    // insertBefore relies on the next sibling to be
+    // resolved.
+    var targetNext, currentNext
+    i = vms.length
+    while (i--) {
+      vm = vms[i]
+      // this is the vm that we should be in front of
+      targetNext = vms[i + 1]
+      if (!targetNext) {
+        // This is the last item. If it's reused then
+        // everything else will eventually be in the right
+        // place, so no need to touch it. Otherwise, insert
+        // it.
+        if (!vm._reused) {
+          vm.$before(ref)
+        }
+      } else {
+        if (vm._reused) {
+          // this is the vm we are actually in front of
+          currentNext = findNextVm(vm, ref)
+          // we only need to move if we are not in the right
+          // place already.
+          if (currentNext !== targetNext) {
+            vm.$before(targetNext.$el, null, false)
+          }
+        } else {
+          // new instance, insert to existing next
+          vm.$before(targetNext.$el)
+        }
+      }
+      vm._new = false
+      vm._reused = false
+    }
+    return vms
+  },
+
+  /**
+   * Build a new instance and cache it.
+   *
+   * @param {Object} data
+   * @param {Number} index
+   */
+
+  build: function (data, index) {
+    var original = data
+    var meta = { $index: index }
+    if (this.converted) {
+      meta.$key = original.key
+    }
+    var raw = this.converted ? data.value : data
+    var alias = this.arg
+    var hasAlias = !isObject(raw) || alias
+    // wrap the raw data with alias
+    data = hasAlias ? {} : raw
+    if (alias) {
+      data[alias] = raw
+    } else if (hasAlias) {
+      meta.$value = raw
+    }
+    // resolve constructor
+    var Ctor = this.Ctor || this.resolveCtor(data, meta)
+    var vm = this.vm.$addChild({
+      el: templateParser.clone(this.template),
+      _linker: this._linker,
+      _meta: meta,
+      data: data,
+      inherit: this.inherit
+    }, Ctor)
+    // cache instance
+    this.cacheVm(raw, vm)
+    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])
+    }
+    for (key in meta) {
+      _.define(context, key, meta[key])
+    }
+    var id = this.ctorGetter.call(context, context)
+    var Ctor = this.vm.$options.components[id]
+    _.assertAsset(Ctor, 'component', id)
+    return Ctor
+  },
+
+  /**
+   * Unbind, teardown everything
+   */
+
+  unbind: function () {
+    if (this.childId) {
+      delete this.vm.$[this.childId]
+    }
+    if (this.vms) {
+      var i = this.vms.length
+      var vm
+      while (i--) {
+        vm = this.vms[i]
+        this.uncacheVm(vm)
+        vm.$destroy()
+      }
+    }
+  },
+
+  /**
+   * Cache a vm instance based on its data.
+   *
+   * If the data is an object, we save the vm's reference on
+   * the data object as a hidden property. Otherwise we
+   * cache them in an object and for each primitive value
+   * there is an array in case there are duplicates.
+   *
+   * @param {Object} data
+   * @param {Vue} vm
+   */
+
+  cacheVm: function (data, vm) {
+    var idKey = this.idKey
+    var cache = this.cache
+    var id
+    if (idKey) {
+      id = data[idKey]
+      if (!cache[id]) {
+        cache[id] = vm
+      } else {
+        _.warn('Duplicate ID in v-repeat: ' + id)
+      }
+    } else if (isObject(data)) {
+      id = this.id
+      if (data.hasOwnProperty(id)) {
+        if (data[id] === null) {
+          data[id] = vm
+        } else {
+          _.warn(
+            'Duplicate objects are not supported in v-repeat.'
+          )
+        }
+      } else {
+        _.define(data, this.id, vm)
+      }
+    } else {
+      if (!cache[data]) {
+        cache[data] = [vm]
+      } else {
+        cache[data].push(vm)
+      }
+    }
+    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]
+    } 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
+    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()
+    }
+  }
+
 }
 
-// Helpers --------------------------------------------------------------------
+/**
+ * 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 {CommentNode} ref
+ * @return {Vue}
+ */
+
+function findNextVm (vm, ref) {
+  var el = (vm._blockEnd || vm.$el).nextSibling
+  while (!el.__vue__ && el !== ref) {
+    el = el.nextSibling
+  }
+  return el.__vue__
+}
 
 /**
- *  Find an object or a wrapped data object
- *  from an Array
+ * 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.
+ *
+ * @param {*} obj
+ * @return {Array}
+ * @private
  */
-function indexOf (vms, obj) {
-    for (var vm, i = 0, l = vms.length; i < l; i++) {
-        vm = vms[i]
-        if (!vm.$reused && vm.$value === obj) {
-            return i
-        }
+
+function objToArray (obj) {
+  if (!_.isPlainObject(obj)) {
+    return obj
+  }
+  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 -1
+  }
+  // `this` points to the repeat directive instance
+  this.converted = true
+  return res
+}
+
+/**
+ * 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
 }
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/show.js b/vendor/assets/javascripts/bower/vue/src/directives/show.js
new file mode 100644
index 0000000..aa52281
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/show.js
@@ -0,0 +1,8 @@
+var transition = require('../transition')
+
+module.exports = function (value) {
+  var el = this.el
+  transition.apply(el, value ? 1 : -1, function () {
+    el.style.display = value ? '' : 'none'
+  }, this.vm)
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/style.js b/vendor/assets/javascripts/bower/vue/src/directives/style.js
index 56f02ff..fd4b8b4 100644
--- a/vendor/assets/javascripts/bower/vue/src/directives/style.js
+++ b/vendor/assets/javascripts/bower/vue/src/directives/style.js
@@ -1,46 +1,46 @@
 var prefixes = ['-webkit-', '-moz-', '-ms-']
+var importantRE = /!important;?$/
 
-/**
- *  Binding for CSS styles
- */
 module.exports = {
 
-    bind: function () {
-        var prop = this.arg
-        if (!prop) return
-        if (prop.charAt(0) === '$') {
-            // properties that start with $ will be auto-prefixed
-            prop = prop.slice(1)
-            this.prefixed = true
-        }
-        this.prop = prop
-    },
-
-    update: function (value) {
-        var prop = this.prop,
-            isImportant
-        /* jshint eqeqeq: true */
-        // cast possible numbers/booleans into strings
-        if (value != null) value += ''
-        if (prop) {
-            if (value) {
-                isImportant = value.slice(-10) === '!important'
-                    ? 'important'
-                    : ''
-                if (isImportant) {
-                    value = value.slice(0, -10).trim()
-                }
-            }
-            this.el.style.setProperty(prop, value, isImportant)
-            if (this.prefixed) {
-                var i = prefixes.length
-                while (i--) {
-                    this.el.style.setProperty(prefixes[i] + prop, value, isImportant)
-                }
-            }
-        } else {
-            this.el.style.cssText = value
-        }
+  bind: function () {
+    var prop = this.arg
+    if (!prop) return
+    if (prop.charAt(0) === '$') {
+      // properties that start with $ will be auto-prefixed
+      prop = prop.slice(1)
+      this.prefixed = true
     }
+    this.prop = prop
+  },
+
+  update: function (value) {
+    var prop = this.prop
+    // cast possible numbers/booleans into strings
+    if (value != null) {
+      value += ''
+    }
+    if (prop) {
+      var isImportant = importantRE.test(value)
+        ? 'important'
+        : ''
+      if (isImportant) {
+        value = value.replace(importantRE, '').trim()
+      }
+      this.el.style.setProperty(prop, value, isImportant)
+      if (this.prefixed) {
+        var i = prefixes.length
+        while (i--) {
+          this.el.style.setProperty(
+            prefixes[i] + prop,
+            value,
+            isImportant
+          )
+        }
+      }
+    } else {
+      this.el.style.cssText = value
+    }
+  }
 
 }
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/text.js b/vendor/assets/javascripts/bower/vue/src/directives/text.js
new file mode 100644
index 0000000..1650322
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/text.js
@@ -0,0 +1,15 @@
+var _ = require('../util')
+
+module.exports = {
+
+  bind: function () {
+    this.attr = this.el.nodeType === 3
+      ? 'nodeValue'
+      : 'textContent'
+  },
+
+  update: function (value) {
+    this.el[this.attr] = _.toString(value)
+  }
+  
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/transition.js b/vendor/assets/javascripts/bower/vue/src/directives/transition.js
new file mode 100644
index 0000000..3c2472f
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/directives/transition.js
@@ -0,0 +1,12 @@
+module.exports = {
+
+  priority: 1000,
+  isLiteral: true,
+
+  bind: function () {
+    this.el.__v_trans = {
+      id: this.expression
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/view.js b/vendor/assets/javascripts/bower/vue/src/directives/view.js
deleted file mode 100644
index fadc507..0000000
--- a/vendor/assets/javascripts/bower/vue/src/directives/view.js
+++ /dev/null
@@ -1,56 +0,0 @@
-/**
- *  Manages a conditional child VM using the
- *  binding's value as the component ID.
- */
-module.exports = {
-
-    bind: function () {
-
-        // track position in DOM with a ref node
-        var el       = this.raw = this.el,
-            parent   = el.parentNode,
-            ref      = this.ref = document.createComment('v-view')
-        parent.insertBefore(ref, el)
-        parent.removeChild(el)
-
-        // cache original content
-        /* jshint boss: true */
-        var node,
-            frag = this.inner = document.createElement('div')
-        while (node = el.firstChild) {
-            frag.appendChild(node)
-        }
-
-    },
-
-    update: function(value) {
-
-        this.unbind()
-
-        var Ctor  = this.compiler.getOption('components', value)
-        if (!Ctor) return
-
-        this.childVM = new Ctor({
-            el: this.raw.cloneNode(true),
-            parent: this.vm,
-            compilerOptions: {
-                rawContent: this.inner.cloneNode(true)
-            }
-        })
-
-        this.el = this.childVM.$el
-        if (this.compiler.init) {
-            this.ref.parentNode.insertBefore(this.el, this.ref)
-        } else {
-            this.childVM.$before(this.ref)
-        }
-
-    },
-
-    unbind: function() {
-        if (this.childVM) {
-            this.childVM.$destroy()
-        }
-    }
-
-}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/directives/with.js b/vendor/assets/javascripts/bower/vue/src/directives/with.js
index cb7d4b2..95dc958 100644
--- a/vendor/assets/javascripts/bower/vue/src/directives/with.js
+++ b/vendor/assets/javascripts/bower/vue/src/directives/with.js
@@ -1,50 +1,47 @@
-var utils = require('../utils')
+var _ = require('../util')
+var Watcher = require('../watcher')
 
-/**
- *  Binding for inheriting data from parent VMs.
- */
 module.exports = {
 
-    bind: function () {
+  priority: 900,
 
-        var self      = this,
-            childKey  = self.arg,
-            parentKey = self.key,
-            compiler  = self.compiler,
-            owner     = self.binding.compiler
-
-        if (compiler === owner) {
-            this.alone = true
-            return
-        }
-
-        if (childKey) {
-            if (!compiler.bindings[childKey]) {
-                compiler.createBinding(childKey)
+  bind: function () {
+    var vm = this.vm
+    if (this.el !== vm.$el) {
+      _.warn(
+        'v-with can only be used on instance root elements.'
+      )
+    } else if (!vm.$parent) {
+      _.warn(
+        'v-with must be used on an instance with a parent.'
+      )
+    } else {
+      var key = this.arg
+      this.watcher = new Watcher(
+        vm.$parent,
+        this.expression,
+        key
+          ? function (val) {
+              vm.$set(key, val)
             }
-            // sync changes on child back to parent
-            compiler.observer.on('change:' + childKey, function (val) {
-                if (compiler.init) return
-                if (!self.lock) {
-                    self.lock = true
-                    utils.nextTick(function () {
-                        self.lock = false
-                    })
-                }
-                owner.vm.$set(parentKey, val)
-            })
-        }
-    },
-
-    update: function (value) {
-        // sync from parent
-        if (!this.alone && !this.lock) {
-            if (this.arg) {
-                this.vm.$set(this.arg, value)
-            } else if (this.vm.$data !== value) {
-                this.vm.$data = value
+          : function (val) {
+              vm.$data = val
             }
-        }
+      )
+      // initial set
+      var initialVal = this.watcher.value
+      if (key) {
+        vm.$set(key, initialVal)
+      } else {
+        vm.$data = initialVal
+      }
     }
+  },
+
+  unbind: function () {
+    if (this.watcher) {
+      this.watcher.teardown()
+    }
+  }
 
 }
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/emitter.js b/vendor/assets/javascripts/bower/vue/src/emitter.js
deleted file mode 100644
index 5de2ae7..0000000
--- a/vendor/assets/javascripts/bower/vue/src/emitter.js
+++ /dev/null
@@ -1,97 +0,0 @@
-var slice = [].slice
-
-function Emitter (ctx) {
-    this._ctx = ctx || this
-}
-
-var EmitterProto = Emitter.prototype
-
-EmitterProto.on = function (event, fn) {
-    this._cbs = this._cbs || {}
-    ;(this._cbs[event] = this._cbs[event] || [])
-        .push(fn)
-    return this
-}
-
-EmitterProto.once = function (event, fn) {
-    var self = this
-    this._cbs = this._cbs || {}
-
-    function on () {
-        self.off(event, on)
-        fn.apply(this, arguments)
-    }
-
-    on.fn = fn
-    this.on(event, on)
-    return this
-}
-
-EmitterProto.off = function (event, fn) {
-    this._cbs = this._cbs || {}
-
-    // all
-    if (!arguments.length) {
-        this._cbs = {}
-        return this
-    }
-
-    // specific event
-    var callbacks = this._cbs[event]
-    if (!callbacks) return this
-
-    // remove all handlers
-    if (arguments.length === 1) {
-        delete this._cbs[event]
-        return this
-    }
-
-    // remove specific handler
-    var cb
-    for (var i = 0; i < callbacks.length; i++) {
-        cb = callbacks[i]
-        if (cb === fn || cb.fn === fn) {
-            callbacks.splice(i, 1)
-            break
-        }
-    }
-    return this
-}
-
-/**
- *  The internal, faster emit with fixed amount of arguments
- *  using Function.call
- */
-EmitterProto.emit = function (event, a, b, c) {
-    this._cbs = this._cbs || {}
-    var callbacks = this._cbs[event]
-
-    if (callbacks) {
-        callbacks = callbacks.slice(0)
-        for (var i = 0, len = callbacks.length; i < len; i++) {
-            callbacks[i].call(this._ctx, a, b, c)
-        }
-    }
-
-    return this
-}
-
-/**
- *  The external emit using Function.apply
- */
-EmitterProto.applyEmit = function (event) {
-    this._cbs = this._cbs || {}
-    var callbacks = this._cbs[event], args
-
-    if (callbacks) {
-        callbacks = callbacks.slice(0)
-        args = slice.call(arguments, 1)
-        for (var i = 0, len = callbacks.length; i < len; i++) {
-            callbacks[i].apply(this._ctx, args)
-        }
-    }
-
-    return this
-}
-
-module.exports = Emitter
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/exp-parser.js b/vendor/assets/javascripts/bower/vue/src/exp-parser.js
deleted file mode 100644
index 2fa2a26..0000000
--- a/vendor/assets/javascripts/bower/vue/src/exp-parser.js
+++ /dev/null
@@ -1,190 +0,0 @@
-var utils           = require('./utils'),
-    STR_SAVE_RE     = /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g,
-    STR_RESTORE_RE  = /"(\d+)"/g,
-    NEWLINE_RE      = /\n/g,
-    CTOR_RE         = new RegExp('constructor'.split('').join('[\'"+, ]*')),
-    UNICODE_RE      = /\\u\d\d\d\d/
-
-// Variable extraction scooped from https://github.com/RubyLouvre/avalon
-
-var KEYWORDS =
-        // keywords
-        'break,case,catch,continue,debugger,default,delete,do,else,false' +
-        ',finally,for,function,if,in,instanceof,new,null,return,switch,this' +
-        ',throw,true,try,typeof,var,void,while,with,undefined' +
-        // reserved
-        ',abstract,boolean,byte,char,class,const,double,enum,export,extends' +
-        ',final,float,goto,implements,import,int,interface,long,native' +
-        ',package,private,protected,public,short,static,super,synchronized' +
-        ',throws,transient,volatile' +
-        // ECMA 5 - use strict
-        ',arguments,let,yield' +
-        // allow using Math in expressions
-        ',Math',
-        
-    KEYWORDS_RE = new RegExp(["\\b" + KEYWORDS.replace(/,/g, '\\b|\\b') + "\\b"].join('|'), 'g'),
-    REMOVE_RE   = /\/\*(?:.|\n)*?\*\/|\/\/[^\n]*\n|\/\/[^\n]*$|'[^']*'|"[^"]*"|[\s\t\n]*\.[\s\t\n]*[$\w\.]+|[\{,]\s*[\w\$_]+\s*:/g,
-    SPLIT_RE    = /[^\w$]+/g,
-    NUMBER_RE   = /\b\d[^,]*/g,
-    BOUNDARY_RE = /^,+|,+$/g
-
-/**
- *  Strip top level variable names from a snippet of JS expression
- */
-function getVariables (code) {
-    code = code
-        .replace(REMOVE_RE, '')
-        .replace(SPLIT_RE, ',')
-        .replace(KEYWORDS_RE, '')
-        .replace(NUMBER_RE, '')
-        .replace(BOUNDARY_RE, '')
-    return code
-        ? code.split(/,+/)
-        : []
-}
-
-/**
- *  A given path could potentially exist not on the
- *  current compiler, but up in the parent chain somewhere.
- *  This function generates an access relationship string
- *  that can be used in the getter function by walking up
- *  the parent chain to check for key existence.
- *
- *  It stops at top parent if no vm in the chain has the
- *  key. It then creates any missing bindings on the
- *  final resolved vm.
- */
-function traceScope (path, compiler, data) {
-    var rel  = '',
-        dist = 0,
-        self = compiler
-
-    if (data && utils.get(data, path) !== undefined) {
-        // hack: temporarily attached data
-        return '$temp.'
-    }
-
-    while (compiler) {
-        if (compiler.hasKey(path)) {
-            break
-        } else {
-            compiler = compiler.parent
-            dist++
-        }
-    }
-    if (compiler) {
-        while (dist--) {
-            rel += '$parent.'
-        }
-        if (!compiler.bindings[path] && path.charAt(0) !== '$') {
-            compiler.createBinding(path)
-        }
-    } else {
-        self.createBinding(path)
-    }
-    return rel
-}
-
-/**
- *  Create a function from a string...
- *  this looks like evil magic but since all variables are limited
- *  to the VM's data it's actually properly sandboxed
- */
-function makeGetter (exp, raw) {
-    var fn
-    try {
-        fn = new Function(exp)
-    } catch (e) {
-        utils.warn('Error parsing expression: ' + raw)
-    }
-    return fn
-}
-
-/**
- *  Escape a leading dollar sign for regex construction
- */
-function escapeDollar (v) {
-    return v.charAt(0) === '$'
-        ? '\\' + v
-        : v
-}
-
-/**
- *  Parse and return an anonymous computed property getter function
- *  from an arbitrary expression, together with a list of paths to be
- *  created as bindings.
- */
-exports.parse = function (exp, compiler, data) {
-    // unicode and 'constructor' are not allowed for XSS security.
-    if (UNICODE_RE.test(exp) || CTOR_RE.test(exp)) {
-        utils.warn('Unsafe expression: ' + exp)
-        return
-    }
-    // extract variable names
-    var vars = getVariables(exp)
-    if (!vars.length) {
-        return makeGetter('return ' + exp, exp)
-    }
-    vars = utils.unique(vars)
-
-    var accessors = '',
-        has       = utils.hash(),
-        strings   = [],
-        // construct a regex to extract all valid variable paths
-        // ones that begin with "$" are particularly tricky
-        // because we can't use \b for them
-        pathRE = new RegExp(
-            "[^$\\w\\.](" +
-            vars.map(escapeDollar).join('|') +
-            ")[$\\w\\.]*\\b", 'g'
-        ),
-        body = (' ' + exp)
-            .replace(STR_SAVE_RE, saveStrings)
-            .replace(pathRE, replacePath)
-            .replace(STR_RESTORE_RE, restoreStrings)
-
-    body = accessors + 'return ' + body
-
-    function saveStrings (str) {
-        var i = strings.length
-        // escape newlines in strings so the expression
-        // can be correctly evaluated
-        strings[i] = str.replace(NEWLINE_RE, '\\n')
-        return '"' + i + '"'
-    }
-
-    function replacePath (path) {
-        // keep track of the first char
-        var c = path.charAt(0)
-        path = path.slice(1)
-        var val = 'this.' + traceScope(path, compiler, data) + path
-        if (!has[path]) {
-            accessors += val + ';'
-            has[path] = 1
-        }
-        // don't forget to put that first char back
-        return c + val
-    }
-
-    function restoreStrings (str, i) {
-        return strings[i]
-    }
-
-    return makeGetter(body, exp)
-}
-
-/**
- *  Evaluate an expression in the context of a compiler.
- *  Accepts additional data.
- */
-exports.eval = function (exp, compiler, data) {
-    var getter = exports.parse(exp, compiler, data), res
-    if (getter) {
-        // hack: temporarily attach the additional data so
-        // it can be accessed in the getter
-        compiler.vm.$temp = data
-        res = getter.call(compiler.vm)
-        delete compiler.vm.$temp
-    }
-    return res
-}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/filters.js b/vendor/assets/javascripts/bower/vue/src/filters.js
deleted file mode 100644
index 950a7c4..0000000
--- a/vendor/assets/javascripts/bower/vue/src/filters.js
+++ /dev/null
@@ -1,191 +0,0 @@
-var utils    = require('./utils'),
-    get      = utils.get,
-    slice    = [].slice,
-    QUOTE_RE = /^'.*'$/,
-    filters  = module.exports = utils.hash()
-
-/**
- *  'abc' => 'Abc'
- */
-filters.capitalize = function (value) {
-    if (!value && value !== 0) return ''
-    value = value.toString()
-    return value.charAt(0).toUpperCase() + value.slice(1)
-}
-
-/**
- *  'abc' => 'ABC'
- */
-filters.uppercase = function (value) {
-    return (value || value === 0)
-        ? value.toString().toUpperCase()
-        : ''
-}
-
-/**
- *  'AbC' => 'abc'
- */
-filters.lowercase = function (value) {
-    return (value || value === 0)
-        ? value.toString().toLowerCase()
-        : ''
-}
-
-/**
- *  12345 => $12,345.00
- */
-filters.currency = function (value, sign) {
-    value = parseFloat(value)
-    if (!value && value !== 0) return ''
-    sign = sign || '$'
-    var s = Math.floor(value).toString(),
-        i = s.length % 3,
-        h = i > 0 ? (s.slice(0, i) + (s.length > 3 ? ',' : '')) : '',
-        f = '.' + value.toFixed(2).slice(-2)
-    return sign + h + s.slice(i).replace(/(\d{3})(?=\d)/g, '$1,') + f
-}
-
-/**
- *  args: 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']
- */
-filters.pluralize = function (value) {
-    var args = slice.call(arguments, 1)
-    return args.length > 1
-        ? (args[value - 1] || args[args.length - 1])
-        : (args[value - 1] || args[0] + 's')
-}
-
-/**
- *  A special filter that takes a handler function,
- *  wraps it so it only gets triggered on specific keypresses.
- *
- *  v-on only
- */
-
-var keyCodes = {
-    enter    : 13,
-    tab      : 9,
-    'delete' : 46,
-    up       : 38,
-    left     : 37,
-    right    : 39,
-    down     : 40,
-    esc      : 27
-}
-
-filters.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)
-        }
-    }
-}
-
-/**
- *  Filter filter for v-repeat
- */
-filters.filterBy = function (arr, searchKey, delimiter, dataKey) {
-
-    // allow optional `in` delimiter
-    // because why not
-    if (delimiter && delimiter !== 'in') {
-        dataKey = delimiter
-    }
-
-    // get the search string
-    var search = stripQuotes(searchKey) || this.$get(searchKey)
-    if (!search) return arr
-    search = search.toLowerCase()
-
-    // get the optional dataKey
-    dataKey = dataKey && (stripQuotes(dataKey) || this.$get(dataKey))
-
-    // convert object to array
-    if (!Array.isArray(arr)) {
-        arr = utils.objectToArray(arr)
-    }
-
-    return arr.filter(function (item) {
-        return dataKey
-            ? contains(get(item, dataKey), search)
-            : contains(item, search)
-    })
-
-}
-
-filters.filterBy.computed = true
-
-/**
- *  Sort fitler for v-repeat
- */
-filters.orderBy = function (arr, sortKey, reverseKey) {
-
-    var key = stripQuotes(sortKey) || this.$get(sortKey)
-    if (!key) return arr
-
-    // convert object to array
-    if (!Array.isArray(arr)) {
-        arr = utils.objectToArray(arr)
-    }
-
-    var order = 1
-    if (reverseKey) {
-        if (reverseKey === '-1') {
-            order = -1
-        } else if (reverseKey.charAt(0) === '!') {
-            reverseKey = reverseKey.slice(1)
-            order = this.$get(reverseKey) ? 1 : -1
-        } else {
-            order = this.$get(reverseKey) ? -1 : 1
-        }
-    }
-
-    // sort on a copy to avoid mutating original array
-    return arr.slice().sort(function (a, b) {
-        a = get(a, key)
-        b = get(b, key)
-        return a === b ? 0 : a > b ? order : -order
-    })
-
-}
-
-filters.orderBy.computed = true
-
-// Array filter helpers -------------------------------------------------------
-
-/**
- *  String contain helper
- */
-function contains (val, search) {
-    /* jshint eqeqeq: false */
-    if (utils.isObject(val)) {
-        for (var key in val) {
-            if (contains(val[key], search)) {
-                return true
-            }
-        }
-    } else if (val != null) {
-        return val.toString().toLowerCase().indexOf(search) > -1
-    }
-}
-
-/**
- *  Test whether a string is in quotes,
- *  if yes return stripped string
- */
-function stripQuotes (str) {
-    if (QUOTE_RE.test(str)) {
-        return str.slice(1, -1)
-    }
-}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/filters/array-filters.js b/vendor/assets/javascripts/bower/vue/src/filters/array-filters.js
new file mode 100644
index 0000000..f87194a
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/filters/array-filters.js
@@ -0,0 +1,87 @@
+var _ = require('../util')
+var Path = require('../parse/path')
+
+/**
+ * Filter filter for v-repeat
+ *
+ * @param {String} searchKey
+ * @param {String} [delimiter]
+ * @param {String} dataKey
+ */
+
+exports.filterBy = function (arr, searchKey, delimiter, dataKey) {
+  // allow optional `in` delimiter
+  // because why not
+  if (delimiter && delimiter !== 'in') {
+    dataKey = delimiter
+  }
+  // get the search string
+  var search =
+    _.stripQuotes(searchKey) ||
+    this.$get(searchKey)
+  if (!search) {
+    return arr
+  }
+  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)
+  })
+}
+
+/**
+ * Filter filter for v-repeat
+ *
+ * @param {String} sortKey
+ * @param {String} reverseKey
+ */
+
+exports.orderBy = function (arr, sortKey, reverseKey) {
+  var key =
+    _.stripQuotes(sortKey) ||
+    this.$get(sortKey)
+  if (!key) {
+    return arr
+  }
+  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
+    }
+  }
+  // sort on a copy to avoid mutating original array
+  return arr.slice().sort(function (a, b) {
+    a = Path.get(a, key)
+    b = Path.get(b, key)
+    return a === b ? 0 : a > b ? order : -order
+  })
+}
+
+/**
+ * String contain helper
+ *
+ * @param {*} val
+ * @param {String} search
+ */
+
+function contains (val, search) {
+  if (_.isObject(val)) {
+    for (var key in val) {
+      if (contains(val[key], search)) {
+        return true
+      }
+    }
+  } else if (val != null) {
+    return val.toString().toLowerCase().indexOf(search) > -1
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/filters/index.js b/vendor/assets/javascripts/bower/vue/src/filters/index.js
new file mode 100644
index 0000000..cf3c5b2
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/filters/index.js
@@ -0,0 +1,121 @@
+var _ = require('../util')
+
+/**
+ * Stringify value.
+ *
+ * @param {Number} indent
+ */
+
+exports.json = function (value, indent) {
+  return JSON.stringify(value, null, Number(indent) || 2)
+}
+
+/**
+ * '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 (!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 ? ',' : ''))
+      : '',
+    f = '.' + value.toFixed(2).slice(-2)
+  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.
+ *
+ *  e.g. ['single', 'double', 'triple', 'multiple']
+ */
+
+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'))
+}
+
+/**
+ * A special filter that takes a handler function,
+ * wraps it so it only gets triggered on specific
+ * keypresses. v-on only.
+ *
+ * @param {String} key
+ */
+
+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)
+    }
+  }
+}
+
+/**
+ * Install special array filters
+ */
+
+_.extend(exports, require('./array-filters'))
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/fragment.js b/vendor/assets/javascripts/bower/vue/src/fragment.js
deleted file mode 100644
index eba460e..0000000
--- a/vendor/assets/javascripts/bower/vue/src/fragment.js
+++ /dev/null
@@ -1,67 +0,0 @@
-// string -> DOM conversion
-// wrappers originally from jQuery, scooped from component/domify
-var map = {
-    legend   : [1, '<fieldset>', '</fieldset>'],
-    tr       : [2, '<table><tbody>', '</tbody></table>'],
-    col      : [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
-    _default : [0, '', '']
-}
-
-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.text =
-map.circle =
-map.ellipse =
-map.line =
-map.path =
-map.polygon =
-map.polyline =
-map.rect = [1, '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">','</svg>']
-
-var TAG_RE = /<([\w:]+)/
-
-module.exports = function (templateString) {
-    var frag = document.createDocumentFragment(),
-        m = TAG_RE.exec(templateString)
-    // text only
-    if (!m) {
-        frag.appendChild(document.createTextNode(templateString))
-        return frag
-    }
-
-    var tag = m[1],
-        wrap = map[tag] || map._default,
-        depth = wrap[0],
-        prefix = wrap[1],
-        suffix = wrap[2],
-        node = document.createElement('div')
-
-    node.innerHTML = prefix + templateString.trim() + suffix
-    while (depth--) node = node.lastChild
-
-    // one element
-    if (node.firstChild === node.lastChild) {
-        frag.appendChild(node.firstChild)
-        return frag
-    }
-
-    // multiple nodes, return a fragment
-    var child
-    /* jshint boss: true */
-    while (child = node.firstChild) {
-        if (node.nodeType === 1) {
-            frag.appendChild(child)
-        }
-    }
-    return frag
-}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/instance/compile.js b/vendor/assets/javascripts/bower/vue/src/instance/compile.js
new file mode 100644
index 0000000..eaaefa0
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/instance/compile.js
@@ -0,0 +1,71 @@
+var _ = require('../util')
+var Directive = require('../directive')
+var compile = require('../compile/compile')
+var transclude = require('../compile/transclude')
+
+/**
+ * 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._compile = function (el) {
+  var options = this.$options
+  if (options._linker) {
+    this._initElement(el)
+    options._linker(this, el)
+  } else {
+    var raw = el
+    el = transclude(el, options)
+    this._initElement(el)
+    var linker = compile(el, options)
+    linker(this, el)
+    if (options.replace) {
+      _.replace(raw, el)
+    }
+  }
+  return el
+}
+
+/**
+ * Initialize instance element. Called in the public
+ * $mount() method.
+ *
+ * @param {Element} el
+ */
+
+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')
+}
+
+/**
+ * Create and bind a directive to an element.
+ *
+ * @param {String} name - directive name
+ * @param {Node} node   - target node
+ * @param {Object} desc - parsed directive descriptor
+ * @param {Object} def  - directive definition object
+ * @param {Function} [linker] - pre-compiled linker fn
+ */
+
+exports._bindDir = function (name, node, desc, def, linker) {
+  this._directives.push(
+    new Directive(name, node, this, desc, def, linker)
+  )
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/instance/events.js b/vendor/assets/javascripts/bower/vue/src/instance/events.js
new file mode 100644
index 0000000..a903cea
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/instance/events.js
@@ -0,0 +1,122 @@
+var _ = require('../util')
+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.
+ */
+
+exports._initEvents = function () {
+  var options = this.$options
+  registerCallbacks(this, '$on', options.events)
+  registerCallbacks(this, '$watch', options.watch)
+}
+
+/**
+ * Register callbacks for option events and watchers.
+ *
+ * @param {Vue} vm
+ * @param {String} action
+ * @param {Object} hash
+ */
+
+function registerCallbacks (vm, action, hash) {
+  if (!hash) return
+  var handlers, key, i, j
+  for (key in hash) {
+    handlers = hash[key]
+    if (_.isArray(handlers)) {
+      for (i = 0, j = handlers.length; i < j; i++) {
+        register(vm, action, key, handlers[i])
+      }
+    } else {
+      register(vm, action, key, handlers)
+    }
+  }
+}
+
+/**
+ * Helper to register an event/watch callback.
+ *
+ * @param {Vue} vm
+ * @param {String} action
+ * @param {String} key
+ * @param {*} handler
+ */
+
+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)
+}
+
+/**
+ * Callback to recursively call attached hook on children
+ */
+
+function onAttached () {
+  this._isAttached = true
+  var children = this._children
+  if (!children) return
+  for (var i = 0, l = children.length; i < l; i++) {
+    var child = children[i]
+    if (!child._isAttached && inDoc(child.$el)) {
+      child._callHook('attached')
+    }
+  }
+}
+
+/**
+ * Callback to recursively call detached hook on children
+ */
+
+function onDetached () {
+  this._isAttached = false
+  var children = this._children
+  if (!children) return
+  for (var i = 0, l = children.length; i < l; i++) {
+    var child = children[i]
+    if (child._isAttached && !inDoc(child.$el)) {
+      child._callHook('detached')
+    }
+  }
+}
+
+/**
+ * Trigger all handlers for a hook
+ *
+ * @param {String} hook
+ */
+
+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)
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/instance/init.js b/vendor/assets/javascripts/bower/vue/src/instance/init.js
new file mode 100644
index 0000000..ecd9599
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/instance/init.js
@@ -0,0 +1,76 @@
+var mergeOptions = require('../util/merge-option')
+
+/**
+ * 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._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
+
+  // children
+  this._children =         // @type {Array}
+  this._childCtors = null  // @type {Object} - hash to cache
+                           // child constructors
+
+  // 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)
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/instance/scope.js b/vendor/assets/javascripts/bower/vue/src/instance/scope.js
new file mode 100644
index 0000000..87e4c5a
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/instance/scope.js
@@ -0,0 +1,217 @@
+var _ = require('../util')
+var Observer = require('../observer')
+var Binding = require('../binding')
+
+/**
+ * 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. 
+ */
+
+exports._initData = function () {
+  // proxy data on instance
+  var data = this._data
+  var keys = Object.keys(data)
+  var i = keys.length
+  var key
+  while (i--) {
+    key = keys[i]
+    if (!_.isReserved(key)) {
+      this._proxy(key)
+    }
+  }
+  // observe data
+  Observer.create(data).addVm(this)
+}
+
+/**
+ * Swap the isntance's $data. Called in $data's setter.
+ *
+ * @param {Object} newData
+ */
+
+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)
+    }
+  }
+  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
+    }
+  })
+}
+
+/**
+ * Unproxy a property.
+ *
+ * @param {String} key
+ */
+
+exports._unproxy = function (key) {
+  delete this[key]
+}
+
+/**
+ * Force update on every watcher in scope.
+ */
+
+exports._digest = function () {
+  var i = this._watcherList.length
+  while (i--) {
+    this._watcherList[i].update()
+  }
+  var children = this._children
+  var child
+  if (children) {
+    i = children.length
+    while (i--) {
+      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)
+    }
+  }
+}
+
+/**
+ * Initialize meta information like $index, $key & $value.
+ */
+
+exports._initMeta = function () {
+  var metas = this.$options._meta
+  if (metas) {
+    for (var key in metas) {
+      this._defineMeta(key, metas[key])
+    }
+  }
+}
+
+/**
+ * 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
+ */
+
+exports._defineMeta = function (key, value) {
+  var binding = new Binding()
+  Object.defineProperty(this, key, {
+    enumerable: true,
+    configurable: true,
+    get: function metaGetter () {
+      if (Observer.target) {
+        Observer.target.addDep(binding)
+      }
+      return value
+    },
+    set: function metaSetter (val) {
+      if (val !== value) {
+        value = val
+        binding.notify()
+      }
+    }
+  })
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/main.js b/vendor/assets/javascripts/bower/vue/src/main.js
deleted file mode 100644
index 3f459e8..0000000
--- a/vendor/assets/javascripts/bower/vue/src/main.js
+++ /dev/null
@@ -1,188 +0,0 @@
-var config      = require('./config'),
-    ViewModel   = require('./viewmodel'),
-    utils       = require('./utils'),
-    makeHash    = utils.hash,
-    assetTypes  = ['directive', 'filter', 'partial', 'effect', 'component'],
-    // Internal modules that are exposed for plugins
-    pluginAPI   = {
-        utils: utils,
-        config: config,
-        transition: require('./transition'),
-        observer: require('./observer')
-    }
-
-ViewModel.options = config.globalAssets = {
-    directives  : require('./directives'),
-    filters     : require('./filters'),
-    partials    : makeHash(),
-    effects     : makeHash(),
-    components  : makeHash()
-}
-
-/**
- *  Expose asset registration methods
- */
-assetTypes.forEach(function (type) {
-    ViewModel[type] = function (id, value) {
-        var hash = this.options[type + 's']
-        if (!hash) {
-            hash = this.options[type + 's'] = makeHash()
-        }
-        if (!value) return hash[id]
-        if (type === 'partial') {
-            value = utils.parseTemplateOption(value)
-        } else if (type === 'component') {
-            value = utils.toConstructor(value)
-        } else if (type === 'filter') {
-            utils.checkFilter(value)
-        }
-        hash[id] = value
-        return this
-    }
-})
-
-/**
- *  Set config options
- */
-ViewModel.config = function (opts, val) {
-    if (typeof opts === 'string') {
-        if (val === undefined) {
-            return config[opts]
-        } else {
-            config[opts] = val
-        }
-    } else {
-        utils.extend(config, opts)
-    }
-    return this
-}
-
-/**
- *  Expose an interface for plugins
- */
-ViewModel.use = function (plugin) {
-    if (typeof plugin === 'string') {
-        try {
-            plugin = require(plugin)
-        } catch (e) {
-            utils.warn('Cannot find plugin: ' + plugin)
-            return
-        }
-    }
-
-    // additional parameters
-    var args = [].slice.call(arguments, 1)
-    args.unshift(this)
-
-    if (typeof plugin.install === 'function') {
-        plugin.install.apply(plugin, args)
-    } else {
-        plugin.apply(null, args)
-    }
-    return this
-}
-
-/**
- *  Expose internal modules for plugins
- */
-ViewModel.require = function (module) {
-    return pluginAPI[module]
-}
-
-ViewModel.extend = extend
-ViewModel.nextTick = utils.nextTick
-
-/**
- *  Expose the main ViewModel class
- *  and add extend method
- */
-function extend (options) {
-
-    var ParentVM = this
-
-    // extend data options need to be copied
-    // on instantiation
-    if (options.data) {
-        options.defaultData = options.data
-        delete options.data
-    }
-
-    // inherit options
-    // but only when the super class is not the native Vue.
-    if (ParentVM !== ViewModel) {
-        options = inheritOptions(options, ParentVM.options, true)
-    }
-    utils.processOptions(options)
-
-    var ExtendedVM = function (opts, asParent) {
-        if (!asParent) {
-            opts = inheritOptions(opts, options, true)
-        }
-        ParentVM.call(this, opts, true)
-    }
-
-    // inherit prototype props
-    var proto = ExtendedVM.prototype = Object.create(ParentVM.prototype)
-    utils.defProtected(proto, 'constructor', ExtendedVM)
-
-    // allow extended VM to be further extended
-    ExtendedVM.extend  = extend
-    ExtendedVM.super   = ParentVM
-    ExtendedVM.options = options
-
-    // allow extended VM to add its own assets
-    assetTypes.forEach(function (type) {
-        ExtendedVM[type] = ViewModel[type]
-    })
-
-    // allow extended VM to use plugins
-    ExtendedVM.use     = ViewModel.use
-    ExtendedVM.require = ViewModel.require
-
-    return ExtendedVM
-}
-
-/**
- *  Inherit options
- *
- *  For options such as `data`, `vms`, `directives`, 'partials',
- *  they should be further extended. However extending should only
- *  be done at top level.
- *  
- *  `proto` is an exception because it's handled directly on the
- *  prototype.
- *
- *  `el` is an exception because it's not allowed as an
- *  extension option, but only as an instance option.
- */
-function inheritOptions (child, parent, topLevel) {
-    child = child || {}
-    if (!parent) return child
-    for (var key in parent) {
-        if (key === 'el') continue
-        var val = child[key],
-            parentVal = parent[key]
-        if (topLevel && typeof val === 'function' && parentVal) {
-            // merge hook functions into an array
-            child[key] = [val]
-            if (Array.isArray(parentVal)) {
-                child[key] = child[key].concat(parentVal)
-            } else {
-                child[key].push(parentVal)
-            }
-        } else if (
-            topLevel &&
-            (utils.isTrueObject(val) || utils.isTrueObject(parentVal))
-            && !(parentVal instanceof ViewModel)
-        ) {
-            // merge toplevel object options
-            child[key] = inheritOptions(val, parentVal)
-        } else if (val === undefined) {
-            // inherit if child doesn't override
-            child[key] = parentVal
-        }
-    }
-    return child
-}
-
-module.exports = ViewModel
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/observer.js b/vendor/assets/javascripts/bower/vue/src/observer.js
deleted file mode 100644
index ba7dfd0..0000000
--- a/vendor/assets/javascripts/bower/vue/src/observer.js
+++ /dev/null
@@ -1,446 +0,0 @@
-/* jshint proto:true */
-
-var Emitter  = require('./emitter'),
-    utils    = require('./utils'),
-    // cache methods
-    def      = utils.defProtected,
-    isObject = utils.isObject,
-    isArray  = Array.isArray,
-    hasOwn   = ({}).hasOwnProperty,
-    oDef     = Object.defineProperty,
-    slice    = [].slice,
-    // fix for IE + __proto__ problem
-    // define methods as inenumerable if __proto__ is present,
-    // otherwise enumerable so we can loop through and manually
-    // attach to array instances
-    hasProto = ({}).__proto__
-
-// Array Mutation Handlers & Augmentations ------------------------------------
-
-// The proxy prototype to replace the __proto__ of
-// an observed array
-var ArrayProxy = Object.create(Array.prototype)
-
-// intercept mutation methods
-;[
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
-].forEach(watchMutation)
-
-// Augment the ArrayProxy with convenience methods
-def(ArrayProxy, '$set', function (index, data) {
-    return this.splice(index, 1, data)[0]
-}, !hasProto)
-
-def(ArrayProxy, '$remove', function (index) {
-    if (typeof index !== 'number') {
-        index = this.indexOf(index)
-    }
-    if (index > -1) {
-        return this.splice(index, 1)[0]
-    }
-}, !hasProto)
-
-/**
- *  Intercep a mutation event so we can emit the mutation info.
- *  we also analyze what elements are added/removed and link/unlink
- *  them with the parent Array.
- */
-function watchMutation (method) {
-    def(ArrayProxy, method, function () {
-
-        var args = slice.call(arguments),
-            result = Array.prototype[method].apply(this, args),
-            inserted, removed
-
-        // determine new / removed elements
-        if (method === 'push' || method === 'unshift') {
-            inserted = args
-        } else if (method === 'pop' || method === 'shift') {
-            removed = [result]
-        } else if (method === 'splice') {
-            inserted = args.slice(2)
-            removed = result
-        }
-        
-        // link & unlink
-        linkArrayElements(this, inserted)
-        unlinkArrayElements(this, removed)
-
-        // emit the mutation event
-        this.__emitter__.emit('mutate', '', this, {
-            method   : method,
-            args     : args,
-            result   : result,
-            inserted : inserted,
-            removed  : removed
-        })
-
-        return result
-        
-    }, !hasProto)
-}
-
-/**
- *  Link new elements to an Array, so when they change
- *  and emit events, the owner Array can be notified.
- */
-function linkArrayElements (arr, items) {
-    if (items) {
-        var i = items.length, item, owners
-        while (i--) {
-            item = items[i]
-            if (isWatchable(item)) {
-                // if object is not converted for observing
-                // convert it...
-                if (!item.__emitter__) {
-                    convert(item)
-                    watch(item)
-                }
-                owners = item.__emitter__.owners
-                if (owners.indexOf(arr) < 0) {
-                    owners.push(arr)
-                }
-            }
-        }
-    }
-}
-
-/**
- *  Unlink removed elements from the ex-owner Array.
- */
-function unlinkArrayElements (arr, items) {
-    if (items) {
-        var i = items.length, item
-        while (i--) {
-            item = items[i]
-            if (item && item.__emitter__) {
-                var owners = item.__emitter__.owners
-                if (owners) owners.splice(owners.indexOf(arr))
-            }
-        }
-    }
-}
-
-// Object add/delete key augmentation -----------------------------------------
-
-var ObjProxy = Object.create(Object.prototype)
-
-def(ObjProxy, '$add', function (key, val) {
-    if (hasOwn.call(this, key)) return
-    this[key] = val
-    convertKey(this, key, true)
-}, !hasProto)
-
-def(ObjProxy, '$delete', function (key) {
-    if (!(hasOwn.call(this, key))) return
-    // trigger set events
-    this[key] = undefined
-    delete this[key]
-    this.__emitter__.emit('delete', key)
-}, !hasProto)
-
-// Watch Helpers --------------------------------------------------------------
-
-/**
- *  Check if a value is watchable
- */
-function isWatchable (obj) {
-    return typeof obj === 'object' && obj && !obj.$compiler
-}
-
-/**
- *  Convert an Object/Array to give it a change emitter.
- */
-function convert (obj) {
-    if (obj.__emitter__) return true
-    var emitter = new Emitter()
-    def(obj, '__emitter__', emitter)
-    emitter
-        .on('set', function (key, val, propagate) {
-            if (propagate) propagateChange(obj)
-        })
-        .on('mutate', function () {
-            propagateChange(obj)
-        })
-    emitter.values = utils.hash()
-    emitter.owners = []
-    return false
-}
-
-/**
- *  Propagate an array element's change to its owner arrays
- */
-function propagateChange (obj) {
-    var owners = obj.__emitter__.owners,
-        i = owners.length
-    while (i--) {
-        owners[i].__emitter__.emit('set', '', '', true)
-    }
-}
-
-/**
- *  Watch target based on its type
- */
-function watch (obj) {
-    if (isArray(obj)) {
-        watchArray(obj)
-    } else {
-        watchObject(obj)
-    }
-}
-
-/**
- *  Augment target objects with modified
- *  methods
- */
-function augment (target, src) {
-    if (hasProto) {
-        target.__proto__ = src
-    } else {
-        for (var key in src) {
-            def(target, key, src[key])
-        }
-    }
-}
-
-/**
- *  Watch an Object, recursive.
- */
-function watchObject (obj) {
-    augment(obj, ObjProxy)
-    for (var key in obj) {
-        convertKey(obj, key)
-    }
-}
-
-/**
- *  Watch an Array, overload mutation methods
- *  and add augmentations by intercepting the prototype chain
- */
-function watchArray (arr) {
-    augment(arr, ArrayProxy)
-    linkArrayElements(arr, arr)
-}
-
-/**
- *  Define accessors for a property on an Object
- *  so it emits get/set events.
- *  Then watch the value itself.
- */
-function convertKey (obj, key, propagate) {
-    var keyPrefix = key.charAt(0)
-    if (keyPrefix === '$' || keyPrefix === '_') {
-        return
-    }
-    // emit set on bind
-    // this means when an object is observed it will emit
-    // a first batch of set events.
-    var emitter = obj.__emitter__,
-        values  = emitter.values
-
-    init(obj[key], propagate)
-
-    oDef(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function () {
-            var value = values[key]
-            // only emit get on tip values
-            if (pub.shouldGet) {
-                emitter.emit('get', key)
-            }
-            return value
-        },
-        set: function (newVal) {
-            var oldVal = values[key]
-            unobserve(oldVal, key, emitter)
-            copyPaths(newVal, oldVal)
-            // an immediate property should notify its parent
-            // to emit set for itself too
-            init(newVal, true)
-        }
-    })
-
-    function init (val, propagate) {
-        values[key] = val
-        emitter.emit('set', key, val, propagate)
-        if (isArray(val)) {
-            emitter.emit('set', key + '.length', val.length, propagate)
-        }
-        observe(val, key, emitter)
-    }
-}
-
-/**
- *  When a value that is already converted is
- *  observed again by another observer, we can skip
- *  the watch conversion and simply emit set event for
- *  all of its properties.
- */
-function emitSet (obj) {
-    var emitter = obj && obj.__emitter__
-    if (!emitter) return
-    if (isArray(obj)) {
-        emitter.emit('set', 'length', obj.length)
-    } else {
-        var key, val
-        for (key in obj) {
-            val = obj[key]
-            emitter.emit('set', key, val)
-            emitSet(val)
-        }
-    }
-}
-
-/**
- *  Make sure all the paths in an old object exists
- *  in a new object.
- *  So when an object changes, all missing keys will
- *  emit a set event with undefined value.
- */
-function copyPaths (newObj, oldObj) {
-    if (!isObject(newObj) || !isObject(oldObj)) {
-        return
-    }
-    var path, oldVal, newVal
-    for (path in oldObj) {
-        if (!(hasOwn.call(newObj, path))) {
-            oldVal = oldObj[path]
-            if (isArray(oldVal)) {
-                newObj[path] = []
-            } else if (isObject(oldVal)) {
-                newVal = newObj[path] = {}
-                copyPaths(newVal, oldVal)
-            } else {
-                newObj[path] = undefined
-            }
-        }
-    }
-}
-
-/**
- *  walk along a path and make sure it can be accessed
- *  and enumerated in that object
- */
-function ensurePath (obj, key) {
-    var path = key.split('.'), sec
-    for (var i = 0, d = path.length - 1; i < d; i++) {
-        sec = path[i]
-        if (!obj[sec]) {
-            obj[sec] = {}
-            if (obj.__emitter__) convertKey(obj, sec)
-        }
-        obj = obj[sec]
-    }
-    if (isObject(obj)) {
-        sec = path[i]
-        if (!(hasOwn.call(obj, sec))) {
-            obj[sec] = undefined
-            if (obj.__emitter__) convertKey(obj, sec)
-        }
-    }
-}
-
-// Main API Methods -----------------------------------------------------------
-
-/**
- *  Observe an object with a given path,
- *  and proxy get/set/mutate events to the provided observer.
- */
-function observe (obj, rawPath, observer) {
-
-    if (!isWatchable(obj)) return
-
-    var path = rawPath ? rawPath + '.' : '',
-        alreadyConverted = convert(obj),
-        emitter = obj.__emitter__
-
-    // setup proxy listeners on the parent observer.
-    // we need to keep reference to them so that they
-    // can be removed when the object is un-observed.
-    observer.proxies = observer.proxies || {}
-    var proxies = observer.proxies[path] = {
-        get: function (key) {
-            observer.emit('get', path + key)
-        },
-        set: function (key, val, propagate) {
-            if (key) observer.emit('set', path + key, val)
-            // also notify observer that the object itself changed
-            // but only do so when it's a immediate property. this
-            // avoids duplicate event firing.
-            if (rawPath && propagate) {
-                observer.emit('set', rawPath, obj, true)
-            }
-        },
-        mutate: function (key, val, mutation) {
-            // if the Array is a root value
-            // the key will be null
-            var fixedPath = key ? path + key : rawPath
-            observer.emit('mutate', fixedPath, val, mutation)
-            // also emit set for Array's length when it mutates
-            var m = mutation.method
-            if (m !== 'sort' && m !== 'reverse') {
-                observer.emit('set', fixedPath + '.length', val.length)
-            }
-        }
-    }
-
-    // attach the listeners to the child observer.
-    // now all the events will propagate upwards.
-    emitter
-        .on('get', proxies.get)
-        .on('set', proxies.set)
-        .on('mutate', proxies.mutate)
-
-    if (alreadyConverted) {
-        // for objects that have already been converted,
-        // emit set events for everything inside
-        emitSet(obj)
-    } else {
-        watch(obj)
-    }
-}
-
-/**
- *  Cancel observation, turn off the listeners.
- */
-function unobserve (obj, path, observer) {
-
-    if (!obj || !obj.__emitter__) return
-
-    path = path ? path + '.' : ''
-    var proxies = observer.proxies[path]
-    if (!proxies) return
-
-    // turn off listeners
-    obj.__emitter__
-        .off('get', proxies.get)
-        .off('set', proxies.set)
-        .off('mutate', proxies.mutate)
-
-    // remove reference
-    observer.proxies[path] = null
-}
-
-// Expose API -----------------------------------------------------------------
-
-var pub = module.exports = {
-
-    // whether to emit get events
-    // only enabled during dependency parsing
-    shouldGet   : false,
-
-    observe     : observe,
-    unobserve   : unobserve,
-    ensurePath  : ensurePath,
-    copyPaths   : copyPaths,
-    watch       : watch,
-    convert     : convert,
-    convertKey  : convertKey
-}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/observer/array.js b/vendor/assets/javascripts/bower/vue/src/observer/array.js
new file mode 100644
index 0000000..fcbc078
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/observer/array.js
@@ -0,0 +1,90 @@
+var _ = require('../util')
+var arrayProto = Array.prototype
+var arrayMethods = Object.create(arrayProto)
+
+/**
+ * Intercept mutating methods and emit events
+ */
+
+;[
+  'push',
+  'pop',
+  'shift',
+  'unshift',
+  'splice',
+  'sort',
+  'reverse'
+]
+.forEach(function (method) {
+  // cache original method
+  var original = arrayProto[method]
+  _.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
+  })
+})
+
+/**
+ * Swap the element at the given index with a new value
+ * and emits corresponding event.
+ *
+ * @param {Number} index
+ * @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]
+  }
+)
+
+/**
+ * Convenience method to remove the element at given index.
+ *
+ * @param {Number} index
+ * @param {*} val
+ */
+
+_.define(
+  arrayProto,
+  '$remove',
+  function $remove (index) {
+    if (typeof index !== 'number') {
+      index = this.indexOf(index)
+    }
+    if (index > -1) {
+      return this.splice(index, 1)[0]
+    }
+  }
+)
+
+module.exports = arrayMethods
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/observer/index.js b/vendor/assets/javascripts/bower/vue/src/observer/index.js
new file mode 100644
index 0000000..50dc084
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/observer/index.js
@@ -0,0 +1,235 @@
+var _ = require('../util')
+var config = require('../config')
+var Binding = require('../binding')
+var arrayMethods = require('./array')
+var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
+require('./object')
+
+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])
+  }
+}
+
+/**
+ * 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.bindings = []
+  _.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)
+  }
+}
+
+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.
+ *
+ * @param {*} value
+ * @return {Observer|undefined}
+ * @static
+ */
+
+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)
+  }
+}
+
+/**
+ * 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 {Object} obj
+ */
+
+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])
+    }
+  }
+}
+
+/**
+ * Try to carete an observer for a child value,
+ * and if value is array, link binding to the array.
+ *
+ * @param {*} val
+ * @return {Binding|undefined}
+ */
+
+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--) {
+    this.observe(items[i])
+  }
+}
+
+/**
+ * Convert a property into getter/setter so we can emit
+ * the events when the property is accessed/changed.
+ *
+ * @param {String} key
+ * @param {*} val
+ */
+
+p.convert = function (key, val) {
+  var ob = this
+  var childOb = ob.observe(val)
+  var binding = new Binding()
+  if (childOb) {
+    childOb.bindings.push(binding)
+  }
+  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(binding)
+      }
+      return val
+    },
+    set: function (newVal) {
+      if (newVal === val) return
+      // remove binding from old value
+      var oldChildOb = val && val.__ob__
+      if (oldChildOb) {
+        var oldBindings = oldChildOb.bindings
+        oldBindings.splice(oldBindings.indexOf(binding), 1)
+      }
+      val = newVal
+      // add binding to new value
+      var newChildOb = ob.observe(newVal)
+      if (newChildOb) {
+        newChildOb.bindings.push(binding)
+      }
+      binding.notify()
+    }
+  })
+}
+
+/**
+ * Notify change on all self bindings 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.
+ */
+
+p.notify = function () {
+  var bindings = this.bindings
+  for (var i = 0, l = bindings.length; i < l; i++) {
+    bindings[i].notify()
+  }
+}
+
+/**
+ * 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 {Vue} vm
+ */
+
+p.addVm = function (vm) {
+  (this.vms = this.vms || []).push(vm)
+}
+
+/**
+ * Remove an owner vm. This is called when the object is
+ * swapped out as an instance's $data object.
+ *
+ * @param {Vue} vm
+ */
+
+p.removeVm = function (vm) {
+  this.vms.splice(this.vms.indexOf(vm), 1)
+}
+
+module.exports = Observer
diff --git a/vendor/assets/javascripts/bower/vue/src/observer/object.js b/vendor/assets/javascripts/bower/vue/src/observer/object.js
new file mode 100644
index 0000000..751f1a1
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/observer/object.js
@@ -0,0 +1,75 @@
+var _ = require('../util')
+var objProto = Object.prototype
+
+/**
+ * Add a new property to an observed object
+ * and emits corresponding event
+ *
+ * @param {String} key
+ * @param {*} val
+ * @public
+ */
+
+_.define(
+  objProto,
+  '$add',
+  function $add (key, val) {
+    var ob = this.__ob__
+    if (!ob) {
+      this[key] = val
+      return
+    }
+    if (_.isReserved(key)) {
+      _.warn('Refused to $add reserved key: ' + key)
+      return
+    }
+    if (this.hasOwnProperty(key)) 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()
+    }
+  }
+)
+
+/**
+ * Deletes a property from an observed object
+ * and emits corresponding event
+ *
+ * @param {String} key
+ * @public
+ */
+
+_.define(
+  objProto,
+  '$delete',
+  function $delete (key) {
+    var ob = this.__ob__
+    if (!ob) {
+      delete this[key]
+      return
+    }
+    if (_.isReserved(key)) {
+      _.warn('Refused to $add reserved key: ' + key)
+      return
+    }
+    if (!this.hasOwnProperty(key)) return
+    delete this[key]
+    if (ob.vms) {
+      var i = ob.vms.length
+      while (i--) {
+        var vm = ob.vms[i]
+        vm._unproxy(key)
+        vm._digest()
+      }
+    } else {
+      ob.notify()
+    }
+  }
+)
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/parse/directive.js b/vendor/assets/javascripts/bower/vue/src/parse/directive.js
new file mode 100644
index 0000000..5db8896
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/parse/directive.js
@@ -0,0 +1,159 @@
+var _ = require('../util')
+var Cache = require('../cache')
+var cache = new Cache(1000)
+var argRE = /^[^\{\?]+$|^'[^']*'$|^"[^"]*"$/
+var filterTokenRE = /[^\s'"]+|'[^']+'|"[^"]+"/g
+
+/**
+ * Parser state
+ */
+
+var str
+var c, i, l
+var inSingle
+var inDouble
+var curly
+var square
+var paren
+var begin
+var argIndex
+var dirs
+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) {
+    dir.expression = str.slice(argIndex, i).trim()
+  } else if (lastFilterIndex !== begin) {
+    pushFilter()
+  }
+  if (i === 0 || dir.expression) {
+    dirs.push(dir)
+  }
+}
+
+/**
+ * Push a filter to the current directive object
+ */
+
+function pushFilter () {
+  var exp = str.slice(lastFilterIndex, i).trim()
+  var filter
+  if (exp) {
+    filter = {}
+    var tokens = exp.match(filterTokenRE)
+    filter.name = tokens[0]
+    filter.args = tokens.length > 1 ? tokens.slice(1) : null
+  }
+  if (filter) {
+    (dir.filters = dir.filters || []).push(filter)
+  }
+  lastFilterIndex = i + 1
+}
+
+/**
+ * Parse a directive string into an Array of AST-like
+ * objects representing directives.
+ *
+ * Example:
+ *
+ * "click: a = a + 1 | uppercase" will yield:
+ * {
+ *   arg: 'click',
+ *   expression: 'a = a + 1',
+ *   filters: [
+ *     { name: 'uppercase', args: null }
+ *   ]
+ * }
+ *
+ * @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
+  curly = square = paren = begin = argIndex = 0
+  lastFilterIndex = 0
+  dirs = []
+  dir = {}
+  arg = null
+
+  for (i = 0, l = str.length; i < l; i++) {
+    c = str.charCodeAt(i)
+    if (inSingle) {
+      // check single quote
+      if (c === 0x27) inSingle = !inSingle
+    } else if (inDouble) {
+      // check double quote
+      if (c === 0x22) inDouble = !inDouble
+    } else if (
+      c === 0x2C && // comma
+      !paren && !curly && !square
+    ) {
+      // reached the end of a directive
+      pushDir()
+      // reset & skip the comma
+      dir = {}
+      begin = argIndex = lastFilterIndex = i + 1
+    } else if (
+      c === 0x3A && // colon
+      !dir.expression &&
+      !dir.arg
+    ) {
+      // argument
+      arg = str.slice(begin, i).trim()
+      // test for valid argument here
+      // since we may have caught stuff like first half of
+      // an object literal or a ternary expression.
+      if (argRE.test(arg)) {
+        argIndex = i + 1
+        dir.arg = _.stripQuotes(arg) || arg
+      }
+    } else if (
+      c === 0x7C && // pipe
+      str.charCodeAt(i + 1) !== 0x7C &&
+      str.charCodeAt(i - 1) !== 0x7C
+    ) {
+      if (dir.expression === undefined) {
+        // first filter, end of expression
+        lastFilterIndex = i + 1
+        dir.expression = str.slice(argIndex, i).trim()
+      } else {
+        // already has filter
+        pushFilter()
+      }
+    } else {
+      switch (c) {
+        case 0x22: inDouble = true; break // "
+        case 0x27: inSingle = true; break // '
+        case 0x28: paren++; break         // (
+        case 0x29: paren--; break         // )
+        case 0x5B: square++; break        // [
+        case 0x5D: square--; break        // ]
+        case 0x7B: curly++; break         // {
+        case 0x7D: curly--; break         // }
+      }
+    }
+  }
+
+  if (i === 0 || begin !== i) {
+    pushDir()
+  }
+
+  cache.put(s, dirs)
+  return dirs
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/parse/expression.js b/vendor/assets/javascripts/bower/vue/src/parse/expression.js
new file mode 100644
index 0000000..121d42a
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/parse/expression.js
@@ -0,0 +1,226 @@
+var _ = require('../util')
+var Path = require('./path')
+var Cache = require('../cache')
+var expressionCache = new Cache(1000)
+
+var keywords =
+  'Math,break,case,catch,continue,debugger,default,' +
+  'delete,do,else,false,finally,for,function,if,in,' +
+  'instanceof,new,null,return,switch,this,throw,true,try,' +
+  'typeof,var,void,while,with,undefined,abstract,boolean,' +
+  'byte,char,class,const,double,enum,export,extends,' +
+  'final,float,goto,implements,import,int,interface,long,' +
+  'native,package,private,protected,public,short,static,' +
+  'super,synchronized,throws,transient,volatile,' +
+  'arguments,let,yield'
+
+var wsRE = /\s/g
+var newlineRE = /\n/g
+var saveRE = /[\{,]\s*[\w\$_]+\s*:|'[^']*'|"[^"]*"/g
+var restoreRE = /"(\d+)"/g
+var pathTestRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*$/
+var pathReplaceRE = /[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g
+var keywordsRE = new RegExp('^(' + keywords.replace(/,/g, '\\b|') + '\\b)')
+
+/**
+ * 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
+ *
+ * @param {String} str
+ * @return {String} - placeholder with index
+ */
+
+function save (str) {
+  var i = saved.length
+  saved[i] = str.replace(newlineRE, '\\n')
+  return '"' + i + '"'
+}
+
+/**
+ * Path rewrite replacer
+ *
+ * @param {String} raw
+ * @return {String}
+ */
+
+function rewrite (raw) {
+  var c = raw.charAt(0)
+  var path = raw.slice(1)
+  if (keywordsRE.test(path)) {
+    return raw
+  } else {
+    path = path.indexOf('"') > -1
+      ? path.replace(restoreRE, restore)
+      : path
+    return c + 'scope.' + path
+  }
+}
+
+/**
+ * Restore replacer
+ *
+ * @param {String} str
+ * @param {String} i - matched save index
+ * @return {String}
+ */
+
+function restore (str, i) {
+  return saved[i]
+}
+
+/**
+ * Rewrite an expression, prefixing all path accessors with
+ * `scope.` and generate getter/setter functions.
+ *
+ * @param {String} exp
+ * @param {Boolean} needSet
+ * @return {Function}
+ */
+
+function compileExpFns (exp, needSet) {
+  // 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
+    }
+  }
+}
+
+/**
+ * Compile getter setters for a simple path.
+ *
+ * @param {String} exp
+ * @return {Function}
+ */
+
+function compilePathFns (exp) {
+  var getter, path
+  if (exp.indexOf('[') < 0) {
+    // really simple path
+    path = exp.split('.')
+    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)
+    }
+  }
+}
+
+/**
+ * Build a getter function. Requires eval.
+ *
+ * We isolate the try/catch so it doesn't affect the
+ * optimization of the parse function when it is not called.
+ *
+ * @param {String} body
+ * @return {Function|undefined}
+ */
+
+function makeGetter (body) {
+  try {
+    return new Function('scope', 'return ' + body + ';')
+  } catch (e) {
+    _.warn(
+      'Invalid expression. ' + 
+      'Generated function body: ' + body
+    )
+  }
+}
+
+/**
+ * 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.
+ *
+ * @param {String} body
+ * @return {Function|undefined}
+ */
+
+function makeSetter (body) {
+  try {
+    return new Function('scope', 'value', body + '=value;')
+  } catch (e) {
+    _.warn('Invalid setter function body: ' + body)
+  }
+}
+
+/**
+ * Check for setter existence on a cache hit.
+ *
+ * @param {Function} hit
+ */
+
+function checkSetter (hit) {
+  if (!hit.set) {
+    hit.set = makeSetter(hit.body)
+  }
+}
+
+/**
+ * Parse an expression into re-written getter/setters.
+ *
+ * @param {String} exp
+ * @param {Boolean} needSet
+ * @return {Function}
+ */
+
+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.
+  var res = pathTestRE.test(exp)
+    ? compilePathFns(exp)
+    : compileExpFns(exp, needSet)
+  expressionCache.put(exp, res)
+  return res
+}
+
+// Export the pathRegex for external use
+exports.pathTestRE = pathTestRE
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/parse/path.js b/vendor/assets/javascripts/bower/vue/src/parse/path.js
new file mode 100644
index 0000000..ff2ae41
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/parse/path.js
@@ -0,0 +1,300 @@
+var _ = require('../util')
+var Cache = require('../cache')
+var pathCache = new Cache(1000)
+var identRE = /^[$_a-zA-Z]+[\w$]*$/
+
+/**
+ * Path-parsing algorithm scooped from Polymer/observe-js
+ */
+
+var pathStateMachine = {
+  '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']
+  }
+}
+
+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: // ]
+    case 0x2E: // .
+    case 0x22: // "
+    case 0x27: // '
+    case 0x30: // 0
+      return char
+
+    case 0x5F: // _
+    case 0x24: // $
+      return 'ident'
+
+    case 0x20: // Space
+    case 0x09: // Tab
+    case 0x0A: // Newline
+    case 0x0D: // Return
+    case 0xA0:  // No-break space
+    case 0xFEFF:  // Byte Order Mark
+    case 0x2028:  // Line Separator
+    case 0x2029:  // Paragraph Separator
+      return 'ws'
+  }
+
+  // a-z, A-Z
+  if ((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
+ *
+ * @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) {
+        return
+      }
+      keys.push(key)
+      key = undefined
+    },
+    append: function() {
+      if (key === undefined) {
+        key = newChar
+      } else {
+        key += newChar
+      }
+    }
+  }
+
+  function maybeUnescapeQuote () {
+    var nextChar = path[index + 1]
+    if ((mode === 'inSingleQuote' && nextChar === "'") ||
+        (mode === 'inDoubleQuote' && nextChar === '"')) {
+      index++
+      newChar = nextChar
+      actions.append()
+      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
+      ? c
+      : transition[2]
+    action()
+
+    if (mode === 'afterPath') {
+      return keys
+    }
+  }
+}
+
+/**
+ * Format a accessor segment based on its type.
+ *
+ * @param {String} key
+ * @return {Boolean}
+ */
+
+function formatAccessor(key) {
+  if (identRE.test(key)) { // identifier
+    return '.' + key
+  } else if (+key === key >>> 0) { // bracket index
+    return '[' + key + ']';
+  } else { // bracket string
+    return '["' + key.replace(/"/g, '\\"') + '"]';
+  }
+}
+
+/**
+ * Compiles a getter function with a fixed path.
+ *
+ * @param {Array} path
+ * @return {Function}
+ */
+
+exports.compileGetter = function (path) {
+  var body =
+    'try{return o' +
+    path.map(formatAccessor).join('') +
+    '}catch(e){};'
+  return new Function('o', body)
+}
+
+/**
+ * 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) {
+    hit = parsePath(path)
+    if (hit) {
+      hit.get = exports.compileGetter(hit)
+      pathCache.put(path, hit)
+    }
+  }
+  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
+ *
+ * @param {Object} obj
+ * @param {String | Array} path
+ * @param {*} val
+ */
+
+exports.set = function (obj, path, val) {
+  if (typeof path === 'string') {
+    path = exports.parse(path)
+  }
+  if (!path || !_.isObject(obj)) {
+    return false
+  }
+  var last, key
+  for (var i = 0, l = path.length - 1; i < l; i++) {
+    last = obj
+    key = path[i]
+    obj = obj[key]
+    if (!_.isObject(obj)) {
+      obj = {}
+      last.$add(key, obj)
+    }
+  }
+  key = path[i]
+  if (key in obj) {
+    obj[key] = val
+  } else {
+    obj.$add(key, val)
+  }
+  return true
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/parse/template.js b/vendor/assets/javascripts/bower/vue/src/parse/template.js
new file mode 100644
index 0000000..0e0bb76
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/parse/template.js
@@ -0,0 +1,222 @@
+var _ = require('../util')
+var Cache = require('../cache')
+var templateCache = new Cache(100)
+
+/**
+ * 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
+
+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 TAG_RE = /<([\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 = TAG_RE.exec(templateString)
+
+  if (!tagMatch) {
+    // text only, return a single text node.
+    frag.appendChild(
+      document.createTextNode(templateString)
+    )
+  } else {
+
+    var tag    = 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
+  }
+  return tag === 'SCRIPT'
+    ? stringToFragment(node.textContent)
+    : stringToFragment(node.innerHTML)
+}
+
+/**
+ * Deal with Safari cloning nested <template> bug by
+ * manually cloning all template instances.
+ *
+ * @param {Element|DocumentFragment} node
+ * @return {Element|DocumentFragment}
+ */
+
+exports.clone = function (node) {
+  var res = node.cloneNode(true)
+  /* istanbul ignore if */
+  if (hasBrokenTemplate) {
+    var templates = node.querySelectorAll('template')
+    if (templates.length) {
+      var cloned = res.querySelectorAll('template')
+      var i = cloned.length
+      while (i--) {
+        cloned[i].parentNode.replaceChild(
+          templates[i].cloneNode(true),
+          cloned[i]
+        )
+      }
+    }
+  }
+  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
+ * @return {DocumentFragment|undefined}
+ */
+
+exports.parse = function (template, clone) {
+  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 (template.charAt(0) === '#') {
+      // id selector can be cached too
+      frag = templateCache.get(template)
+      if (!frag) {
+        node = document.getElementById(template.slice(1))
+        if (node) {
+          frag = nodeToFragment(node)
+          // save selector to cache
+          templateCache.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
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/parse/text.js b/vendor/assets/javascripts/bower/vue/src/parse/text.js
new file mode 100644
index 0000000..82a2f6b
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/parse/text.js
@@ -0,0 +1,178 @@
+var Cache = require('../cache')
+var config = require('../config')
+var dirParser = require('./directive')
+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]
+  var close = config.delimiters[1]
+  firstChar = open.charAt(0)
+  lastChar = close.charAt(close.length - 1)
+  var firstCharRE = escapeRegex(firstChar)
+  var lastCharRE = escapeRegex(lastChar)
+  var openRE = escapeRegex(open)
+  var closeRE = escapeRegex(close)
+  tagRE = new RegExp(
+    firstCharRE + '?' + openRE +
+    '(.+?)' +
+    closeRE + lastCharRE + '?',
+    'g'
+  )
+  htmlRE = new RegExp(
+    '^' + firstCharRE + openRE +
+    '.*' +
+    closeRE + lastCharRE + '$'
+  )
+  // reset cache
+  cache = new Cache(1000)
+}
+
+/**
+ * Parse a template text string into an array of tokens.
+ *
+ * @param {String} text
+ * @return {Array<Object> | null}
+ *               - {String} type
+ *               - {String} value
+ *               - {Boolean} [html]
+ *               - {Boolean} [oneTime]
+ */
+
+exports.parse = function (text) {
+  if (config._delimitersChanged) {
+    compileRegex()
+  }
+  var hit = cache.get(text)
+  if (hit) {
+    return hit
+  }
+  if (!tagRE.test(text)) {
+    return null
+  }
+  var tokens = []
+  var lastIndex = tagRE.lastIndex = 0
+  var match, index, value, first, oneTime, partial
+  /* jshint boss:true */
+  while (match = tagRE.exec(text)) {
+    index = match.index
+    // push text token
+    if (index > lastIndex) {
+      tokens.push({
+        value: text.slice(lastIndex, index)
+      })
+    }
+    // tag token
+    first = match[1].charCodeAt(0)
+    oneTime = first === 0x2A // *
+    partial = first === 0x3E // >
+    value = (oneTime || partial)
+      ? match[1].slice(1)
+      : match[1]
+    tokens.push({
+      tag: true,
+      value: value.trim(),
+      html: htmlRE.test(match[0]),
+      oneTime: oneTime,
+      partial: partial
+    })
+    lastIndex = index + match[0].length
+  }
+  if (lastIndex < text.length) {
+    tokens.push({
+      value: text.slice(lastIndex)
+    })
+  }
+  cache.put(text, tokens)
+  return tokens
+}
+
+/**
+ * Format a list of tokens into an expression.
+ * e.g. tokens parsed from 'a {{b}} c' can be serialized
+ * into one single expression as '"a " + b + " c"'.
+ *
+ * @param {Array} tokens
+ * @param {Vue} [vm]
+ * @return {String}
+ */
+
+exports.tokensToExp = function (tokens, vm) {
+  return tokens.length > 1
+    ? tokens.map(function (token) {
+        return formatToken(token, vm)
+      }).join('+')
+    : formatToken(tokens[0], vm, true)
+}
+
+/**
+ * Format a single token.
+ *
+ * @param {Object} token
+ * @param {Vue} [vm]
+ * @param {Boolean} single
+ * @return {String}
+ */
+
+function formatToken (token, vm, single) {
+  return token.tag
+    ? vm && token.oneTime
+      ? '"' + vm.$eval(token.value) + '"'
+      : single
+        ? token.value
+        : inlineFilters(token.value)
+    : '"' + token.value + '"'
+}
+
+/**
+ * For an attribute with multiple interpolation tags,
+ * e.g. attr="some-{{thing | filter}}", in order to combine
+ * the whole thing into a single watchable expression, we
+ * have to inline those filters. This function does exactly
+ * that. This is a bit hacky but it avoids heavy changes
+ * to directive parser and watcher mechanism.
+ *
+ * @param {String} exp
+ * @return {String}
+ */
+
+var filterRE = /[^|]\|[^|]/
+function inlineFilters (exp) {
+  if (!filterRE.test(exp)) {
+    return '(' + 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('","') + '"'
+          : ''
+        exp = 'this.$options.filters["' + filter.name + '"]' +
+          '.apply(this,[' + exp + args + '])'
+      }
+      return exp
+    }
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/template-parser.js b/vendor/assets/javascripts/bower/vue/src/template-parser.js
deleted file mode 100644
index 09b1d83..0000000
--- a/vendor/assets/javascripts/bower/vue/src/template-parser.js
+++ /dev/null
@@ -1,46 +0,0 @@
-var toFragment = require('./fragment');
-
-/**
- * Parses a template string or node and normalizes it into a
- * a node that can be used as a partial of a template option
- *
- * Possible values include
- * id selector: '#some-template-id'
- * template string: '<div><span>my template</span></div>'
- * DocumentFragment object
- * Node object of type Template
- */
-module.exports = function(template) {
-    var templateNode;
-
-    if (template instanceof window.DocumentFragment) {
-        // if the template is already a document fragment -- do nothing
-        return template
-    }
-
-    if (typeof template === 'string') {
-        // template by ID
-        if (template.charAt(0) === '#') {
-            templateNode = document.getElementById(template.slice(1))
-            if (!templateNode) return
-        } else {
-            return toFragment(template)
-        }
-    } else if (template.nodeType) {
-        templateNode = template
-    } else {
-        return
-    }
-
-    // if its a template tag and the browser supports it,
-    // its content is already a document fragment!
-    if (templateNode.tagName === 'TEMPLATE' && templateNode.content) {
-        return templateNode.content
-    }
-
-    if (templateNode.tagName === 'SCRIPT') {
-        return toFragment(templateNode.innerHTML)
-    }
-
-    return toFragment(templateNode.outerHTML);
-}
diff --git a/vendor/assets/javascripts/bower/vue/src/text-parser.js b/vendor/assets/javascripts/bower/vue/src/text-parser.js
deleted file mode 100644
index 5b8df59..0000000
--- a/vendor/assets/javascripts/bower/vue/src/text-parser.js
+++ /dev/null
@@ -1,96 +0,0 @@
-var openChar        = '{',
-    endChar         = '}',
-    ESCAPE_RE       = /[-.*+?^${}()|[\]\/\\]/g,
-    // lazy require
-    Directive
-
-exports.Regex = buildInterpolationRegex()
-
-function buildInterpolationRegex () {
-    var open = escapeRegex(openChar),
-        end  = escapeRegex(endChar)
-    return new RegExp(open + open + open + '?(.+?)' + end + '?' + end + end)
-}
-
-function escapeRegex (str) {
-    return str.replace(ESCAPE_RE, '\\$&')
-}
-
-function setDelimiters (delimiters) {
-    openChar = delimiters[0]
-    endChar = delimiters[1]
-    exports.delimiters = delimiters
-    exports.Regex = buildInterpolationRegex()
-}
-
-/** 
- *  Parse a piece of text, return an array of tokens
- *  token types:
- *  1. plain string
- *  2. object with key = binding key
- *  3. object with key & html = true
- */
-function parse (text) {
-    if (!exports.Regex.test(text)) return null
-    var m, i, token, match, tokens = []
-    /* jshint boss: true */
-    while (m = text.match(exports.Regex)) {
-        i = m.index
-        if (i > 0) tokens.push(text.slice(0, i))
-        token = { key: m[1].trim() }
-        match = m[0]
-        token.html =
-            match.charAt(2) === openChar &&
-            match.charAt(match.length - 3) === endChar
-        tokens.push(token)
-        text = text.slice(i + m[0].length)
-    }
-    if (text.length) tokens.push(text)
-    return tokens
-}
-
-/**
- *  Parse an attribute value with possible interpolation tags
- *  return a Directive-friendly expression
- *
- *  e.g.  a {{b}} c  =>  "a " + b + " c"
- */
-function parseAttr (attr) {
-    Directive = Directive || require('./directive')
-    var tokens = parse(attr)
-    if (!tokens) return null
-    if (tokens.length === 1) return tokens[0].key
-    var res = [], token
-    for (var i = 0, l = tokens.length; i < l; i++) {
-        token = tokens[i]
-        res.push(
-            token.key
-                ? inlineFilters(token.key)
-                : ('"' + token + '"')
-        )
-    }
-    return res.join('+')
-}
-
-/**
- *  Inlines any possible filters in a binding
- *  so that we can combine everything into a huge expression
- */
-function inlineFilters (key) {
-    if (key.indexOf('|') > -1) {
-        var dirs = Directive.parse(key),
-            dir = dirs && dirs[0]
-        if (dir && dir.filters) {
-            key = Directive.inlineFilters(
-                dir.key,
-                dir.filters
-            )
-        }
-    }
-    return '(' + key + ')'
-}
-
-exports.parse         = parse
-exports.parseAttr     = parseAttr
-exports.setDelimiters = setDelimiters
-exports.delimiters    = [openChar, endChar]
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/transition.js b/vendor/assets/javascripts/bower/vue/src/transition.js
deleted file mode 100644
index 4a51b34..0000000
--- a/vendor/assets/javascripts/bower/vue/src/transition.js
+++ /dev/null
@@ -1,228 +0,0 @@
-var endEvents  = sniffEndEvents(),
-    config     = require('./config'),
-    // batch enter animations so we only force the layout once
-    Batcher    = require('./batcher'),
-    batcher    = new Batcher(),
-    // cache timer functions
-    setTO      = window.setTimeout,
-    clearTO    = window.clearTimeout,
-    // exit codes for testing
-    codes = {
-        CSS_E     : 1,
-        CSS_L     : 2,
-        JS_E      : 3,
-        JS_L      : 4,
-        CSS_SKIP  : -1,
-        JS_SKIP   : -2,
-        JS_SKIP_E : -3,
-        JS_SKIP_L : -4,
-        INIT      : -5,
-        SKIP      : -6
-    }
-
-// force layout before triggering transitions/animations
-batcher._preFlush = function () {
-    /* jshint unused: false */
-    var f = document.body.offsetHeight
-}
-
-/**
- *  stage:
- *    1 = enter
- *    2 = leave
- */
-var transition = module.exports = function (el, stage, cb, compiler) {
-
-    var changeState = function () {
-        cb()
-        compiler.execHook(stage > 0 ? 'attached' : 'detached')
-    }
-
-    if (compiler.init) {
-        changeState()
-        return codes.INIT
-    }
-
-    var hasTransition = el.vue_trans === '',
-        hasAnimation  = el.vue_anim === '',
-        effectId      = el.vue_effect
-
-    if (effectId) {
-        return applyTransitionFunctions(
-            el,
-            stage,
-            changeState,
-            effectId,
-            compiler
-        )
-    } else if (hasTransition || hasAnimation) {
-        return applyTransitionClass(
-            el,
-            stage,
-            changeState,
-            hasAnimation
-        )
-    } else {
-        changeState()
-        return codes.SKIP
-    }
-
-}
-
-/**
- *  Togggle a CSS class to trigger transition
- */
-function applyTransitionClass (el, stage, changeState, hasAnimation) {
-
-    if (!endEvents.trans) {
-        changeState()
-        return codes.CSS_SKIP
-    }
-
-    // if the browser supports transition,
-    // it must have classList...
-    var onEnd,
-        classList        = el.classList,
-        existingCallback = el.vue_trans_cb,
-        enterClass       = config.enterClass,
-        leaveClass       = config.leaveClass,
-        endEvent         = hasAnimation ? endEvents.anim : endEvents.trans
-
-    // cancel unfinished callbacks and jobs
-    if (existingCallback) {
-        el.removeEventListener(endEvent, existingCallback)
-        classList.remove(enterClass)
-        classList.remove(leaveClass)
-        el.vue_trans_cb = null
-    }
-
-    if (stage > 0) { // enter
-
-        // set to enter state before appending
-        classList.add(enterClass)
-        // append
-        changeState()
-        // trigger transition
-        if (!hasAnimation) {
-            batcher.push({
-                execute: function () {
-                    classList.remove(enterClass)
-                }
-            })
-        } else {
-            onEnd = function (e) {
-                if (e.target === el) {
-                    el.removeEventListener(endEvent, onEnd)
-                    el.vue_trans_cb = null
-                    classList.remove(enterClass)
-                }
-            }
-            el.addEventListener(endEvent, onEnd)
-            el.vue_trans_cb = onEnd
-        }
-        return codes.CSS_E
-
-    } else { // leave
-
-        if (el.offsetWidth || el.offsetHeight) {
-            // trigger hide transition
-            classList.add(leaveClass)
-            onEnd = function (e) {
-                if (e.target === el) {
-                    el.removeEventListener(endEvent, onEnd)
-                    el.vue_trans_cb = null
-                    // actually remove node here
-                    changeState()
-                    classList.remove(leaveClass)
-                }
-            }
-            // attach transition end listener
-            el.addEventListener(endEvent, onEnd)
-            el.vue_trans_cb = onEnd
-        } else {
-            // directly remove invisible elements
-            changeState()
-        }
-        return codes.CSS_L
-        
-    }
-
-}
-
-function applyTransitionFunctions (el, stage, changeState, effectId, compiler) {
-
-    var funcs = compiler.getOption('effects', effectId)
-    if (!funcs) {
-        changeState()
-        return codes.JS_SKIP
-    }
-
-    var enter = funcs.enter,
-        leave = funcs.leave,
-        timeouts = el.vue_timeouts
-
-    // clear previous timeouts
-    if (timeouts) {
-        var i = timeouts.length
-        while (i--) {
-            clearTO(timeouts[i])
-        }
-    }
-
-    timeouts = el.vue_timeouts = []
-    function timeout (cb, delay) {
-        var id = setTO(function () {
-            cb()
-            timeouts.splice(timeouts.indexOf(id), 1)
-            if (!timeouts.length) {
-                el.vue_timeouts = null
-            }
-        }, delay)
-        timeouts.push(id)
-    }
-
-    if (stage > 0) { // enter
-        if (typeof enter !== 'function') {
-            changeState()
-            return codes.JS_SKIP_E
-        }
-        enter(el, changeState, timeout)
-        return codes.JS_E
-    } else { // leave
-        if (typeof leave !== 'function') {
-            changeState()
-            return codes.JS_SKIP_L
-        }
-        leave(el, changeState, timeout)
-        return codes.JS_L
-    }
-
-}
-
-/**
- *  Sniff proper transition end event name
- */
-function sniffEndEvents () {
-    var el = document.createElement('vue'),
-        defaultEvent = 'transitionend',
-        events = {
-            'webkitTransition' : 'webkitTransitionEnd',
-            'transition'       : defaultEvent,
-            'mozTransition'    : defaultEvent
-        },
-        ret = {}
-    for (var name in events) {
-        if (el.style[name] !== undefined) {
-            ret.trans = events[name]
-            break
-        }
-    }
-    ret.anim = el.style.animation === ''
-        ? 'animationend'
-        : 'webkitAnimationEnd'
-    return ret
-}
-
-// Expose some stuff for testing purposes
-transition.codes = codes
-transition.sniff = sniffEndEvents
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/transition/css.js b/vendor/assets/javascripts/bower/vue/src/transition/css.js
new file mode 100644
index 0000000..a4efde3
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/transition/css.js
@@ -0,0 +1,189 @@
+var _ = require('../util')
+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)
+  }
+}
+
+/**
+ * Flush the queue, and do one forced reflow before
+ * triggering transitions.
+ */
+
+function flush () {
+  /* jshint unused: false */
+  var f = document.documentElement.offsetHeight
+  queue.forEach(run)
+  queue = []
+  queued = false
+}
+
+/**
+ * Run a transition job.
+ *
+ * @param {Object} job
+ */
+
+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)
+  }
+}
+
+/**
+ * Get an element's transition type based on the
+ * calculated styles
+ *
+ * @param {Element} el
+ * @param {Object} data
+ * @param {String} className
+ * @return {Number}
+ *         1 - transition
+ *         2 - animation
+ */
+
+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
+}
+
+/**
+ * Apply CSS transition to an element.
+ *
+ * @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)
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/transition/index.js b/vendor/assets/javascripts/bower/vue/src/transition/index.js
new file mode 100644
index 0000000..bc50bd5
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/transition/index.js
@@ -0,0 +1,151 @@
+var _ = require('../util')
+var applyCSSTransition = require('./css')
+var applyJSTransition = require('./js')
+
+/**
+ * Append with transition.
+ *
+ * @oaram {Element} el
+ * @param {Element} target
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.append = function (el, target, vm, cb) {
+  apply(el, 1, function () {
+    target.appendChild(el)
+  }, vm, cb)
+}
+
+/**
+ * InsertBefore with transition.
+ *
+ * @oaram {Element} el
+ * @param {Element} target
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.before = function (el, target, vm, cb) {
+  apply(el, 1, function () {
+    _.before(el, target)
+  }, vm, cb)
+}
+
+/**
+ * Remove with transition.
+ *
+ * @oaram {Element} el
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.remove = function (el, vm, cb) {
+  apply(el, -1, function () {
+    _.remove(el)
+  }, vm, cb)
+}
+
+/**
+ * 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]
+ */
+
+exports.removeThenAppend = function (el, target, vm, cb) {
+  apply(el, -1, function () {
+    target.appendChild(el)
+  }, vm, cb)
+}
+
+/**
+ * Append the childNodes of a fragment to target.
+ *
+ * @param {DocumentFragment} block
+ * @param {Node} target
+ * @param {Vue} vm
+ */
+
+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)
+  }
+}
+
+/**
+ * Remove a block of nodes between two edge nodes.
+ *
+ * @param {Node} start
+ * @param {Node} end
+ * @param {Vue} vm
+ */
+
+exports.blockRemove = function (start, end, vm) {
+  var node = start.nextSibling
+  var next
+  while (node !== end) {
+    next = node.nextSibling
+    exports.remove(node, vm)
+    node = next
+  }
+}
+
+/**
+ * Apply transitions with an operation callback.
+ *
+ * @oaram {Element} el
+ * @param {Number} direction
+ *                  1: enter
+ *                 -1: leave
+ * @param {Function} op - the actual DOM operation
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+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 = vm.$options.transitions[transData.id]
+  if (jsTransition) {
+    // js
+    applyJSTransition(
+      el,
+      direction,
+      op,
+      transData,
+      jsTransition,
+      vm,
+      cb
+    )
+  } else if (_.transitionEndEvent) {
+    // css
+    applyCSSTransition(
+      el,
+      direction,
+      op,
+      transData,
+      cb
+    )
+  } else {
+    // not applicable
+    op()
+    if (cb) cb()
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/transition/js.js b/vendor/assets/javascripts/bower/vue/src/transition/js.js
new file mode 100644
index 0000000..89c7f71
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/transition/js.js
@@ -0,0 +1,43 @@
+/**
+ * Apply JavaScript enter/leave functions.
+ *
+ * @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]
+ */
+
+module.exports = function (el, direction, op, data, def, vm, cb) {
+  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()
+    }
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/util/debug.js b/vendor/assets/javascripts/bower/vue/src/util/debug.js
new file mode 100644
index 0000000..91732b8
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/util/debug.js
@@ -0,0 +1,50 @@
+var config = require('../config')
+
+/**
+ * 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) {
+      console.warn('[Vue warn]: ' + msg)
+      if (config.debug && console.trace) {
+        console.trace()
+      }
+    }
+  }
+
+  /**
+   * Assert asset exists
+   */
+
+  exports.assertAsset = function (val, type, id) {
+    if (!val) {
+      exports.warn('Failed to resolve ' + type + ': ' + id)
+    }
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/util/dom.js b/vendor/assets/javascripts/bower/vue/src/util/dom.js
new file mode 100644
index 0000000..55ab70b
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/util/dom.js
@@ -0,0 +1,176 @@
+var config = require('../config')
+
+/**
+ * Check if a node is in the document.
+ *
+ * @param {Node} node
+ * @return {Boolean}
+ */
+
+var doc =
+  typeof document !== 'undefined' &&
+  document.documentElement
+
+exports.inDoc = function (node) {
+  return doc && doc.contains(node)
+}
+
+/**
+ * Extract an attribute from a node.
+ *
+ * @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
+ *
+ * @param {Element} el
+ * @param {Element} target 
+ */
+
+exports.before = function (el, target) {
+  target.parentNode.insertBefore(el, target)
+}
+
+/**
+ * Insert el after target
+ *
+ * @param {Element} el
+ * @param {Element} target 
+ */
+
+exports.after = function (el, target) {
+  if (target.nextSibling) {
+    exports.before(el, target.nextSibling)
+  } else {
+    target.parentNode.appendChild(el)
+  }
+}
+
+/**
+ * Remove el from DOM
+ *
+ * @param {Element} el
+ */
+
+exports.remove = function (el) {
+  el.parentNode.removeChild(el)
+}
+
+/**
+ * Prepend el to target
+ *
+ * @param {Element} el
+ * @param {Element} target 
+ */
+
+exports.prepend = function (el, target) {
+  if (target.firstChild) {
+    exports.before(el, target.firstChild)
+  } else {
+    target.appendChild(el)
+  }
+}
+
+/**
+ * Replace target with el
+ *
+ * @param {Element} target
+ * @param {Element} el
+ */
+
+exports.replace = function (target, el) {
+  var parent = target.parentNode
+  if (parent) {
+    parent.replaceChild(el, target)
+  }
+}
+
+/**
+ * Copy attributes from one element to another.
+ *
+ * @param {Element} from
+ * @param {Element} to
+ */
+
+exports.copyAttributes = function (from, to) {
+  if (from.hasAttributes()) {
+    var attrs = from.attributes
+    for (var i = 0, l = attrs.length; i < l; i++) {
+      var attr = attrs[i]
+      to.setAttribute(attr.name, attr.value)
+    }
+  }
+}
+
+/**
+ * Add event listener shorthand.
+ *
+ * @param {Element} el
+ * @param {String} event
+ * @param {Function} cb
+ */
+
+exports.on = function (el, event, cb) {
+  el.addEventListener(event, cb)
+}
+
+/**
+ * Remove event listener shorthand.
+ *
+ * @param {Element} el
+ * @param {String} event
+ * @param {Function} cb
+ */
+
+exports.off = function (el, event, cb) {
+  el.removeEventListener(event, cb)
+}
+
+/**
+ * Add class with compatibility for IE & SVG
+ *
+ * @param {Element} el
+ * @param {Strong} cls
+ */
+
+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())
+    }
+  }
+}
+
+/**
+ * Remove class with compatibility for IE & SVG
+ *
+ * @param {Element} el
+ * @param {Strong} cls
+ */
+
+exports.removeClass = function (el, cls) {
+  if (el.classList) {
+    el.classList.remove(cls)
+  } else {
+    var cur = ' ' + (el.getAttribute('class') || '') + ' '
+    var tar = ' ' + cls + ' '
+    while (cur.indexOf(tar) >= 0) {
+      cur = cur.replace(tar, ' ')
+    }
+    el.setAttribute('class', cur.trim())
+  }
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/util/env.js b/vendor/assets/javascripts/bower/vue/src/util/env.js
new file mode 100644
index 0000000..b87be40
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/util/env.js
@@ -0,0 +1,74 @@
+/**
+ * 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 the start of the next event loop
+ *
+ * @param {Function} cb
+ * @param {Object} ctx
+ */
+
+var defer = inBrowser
+  ? (window.requestAnimationFrame ||
+    window.webkitRequestAnimationFrame ||
+    setTimeout)
+  : setTimeout
+
+exports.nextTick = function (cb, ctx) {
+  if (ctx) {
+    defer(function () { cb.call(ctx) }, 0)
+  } else {
+    defer(cb, 0)
+  }
+}
+
+/**
+ * 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'
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/util/filter.js b/vendor/assets/javascripts/bower/vue/src/util/filter.js
new file mode 100644
index 0000000..0c383db
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/util/filter.js
@@ -0,0 +1,72 @@
+var _ = require('./debug')
+
+/**
+ * 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.
+ *
+ * @param {Vue} vm
+ * @param {Array<Object>} filters
+ * @param {Object} [target]
+ * @return {Object}
+ */
+
+exports.resolveFilters = function (vm, filters, target) {
+  if (!filters) {
+    return
+  }
+  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 {*}
+ */
+
+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)
+  }
+  return value
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/util/index.js b/vendor/assets/javascripts/bower/vue/src/util/index.js
new file mode 100644
index 0000000..2b96b4d
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/util/index.js
@@ -0,0 +1,8 @@
+var lang   = require('./lang')
+var extend = lang.extend
+
+extend(exports, lang)
+extend(exports, require('./env'))
+extend(exports, require('./dom'))
+extend(exports, require('./filter'))
+extend(exports, require('./debug'))
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/util/lang.js b/vendor/assets/javascripts/bower/vue/src/util/lang.js
new file mode 100644
index 0000000..d36f8db
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/util/lang.js
@@ -0,0 +1,174 @@
+/**
+ * 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
+}
+
+/**
+ * Guard text output, make sure undefined outputs
+ * empty string
+ *
+ * @param {*} value
+ * @return {String}
+ */
+
+exports.toString = function (value) {
+  return value == null
+    ? ''
+    : value.toString()
+}
+
+/**
+ * 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)
+}
+
+/**
+ * Strip quotes from a string
+ *
+ * @param {String} str
+ * @return {String | false}
+ */
+
+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
+}
+
+/**
+ * Camelize a hyphen-delmited string.
+ *
+ * @param {String} str
+ * @return {String}
+ */
+
+var camelRE = /[-_](\w)/g
+var capitalCamelRE = /(?:^|[-_])(\w)/g
+
+exports.camelize = function (str, cap) {
+  var RE = cap ? capitalCamelRE : camelRE
+  return str.replace(RE, function (_, c) {
+    return c ? c.toUpperCase () : '';
+  })
+}
+
+/**
+ * Simple bind, faster than native
+ *
+ * @param {Function} fn
+ * @param {Object} ctx
+ * @return {Function}
+ */
+
+exports.bind = function (fn, ctx) {
+  return function () {
+    return fn.apply(ctx, arguments)
+  }
+}
+
+/**
+ * Convert an Array-like object to a real Array.
+ *
+ * @param {Array-like} list
+ * @param {Number} [start] - start index
+ * @return {Array}
+ */
+
+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]
+  }
+  return ret
+}
+
+/**
+ * Mix properties into target object.
+ *
+ * @param {Object} to
+ * @param {Object} from
+ */
+
+exports.extend = function (to, from) {
+  for (var key in from) {
+    to[key] = from[key]
+  }
+}
+
+/**
+ * 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
+ *
+ * @param {Object} obj
+ * @param {String} key
+ * @param {*} val
+ * @param {Boolean} [enumerable]
+ */
+
+exports.define = function (obj, key, val, enumerable) {
+  Object.defineProperty(obj, key, {
+    value        : val,
+    enumerable   : !!enumerable,
+    writable     : true,
+    configurable : true
+  })
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/util/merge-option.js b/vendor/assets/javascripts/bower/vue/src/util/merge-option.js
new file mode 100644
index 0000000..f2ee962
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/util/merge-option.js
@@ -0,0 +1,229 @@
+var _ = require('./index')
+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)
+
+/**
+ * Data
+ */
+
+strats.data = function (parentVal, childVal, vm) {
+  // in a class merge, both should be functions
+  // so we just return child if it exists
+  if (!vm) {
+    if (childVal && typeof childVal !== 'function') {
+      _.warn(
+        'The "data" option should be a function ' +
+        'that returns a per-instance value in component ' +
+        'definitions.'
+      )
+      return
+    }
+    return childVal || parentVal
+  }
+  var instanceData = typeof childVal === 'function'
+    ? childVal.call(vm)
+    : childVal
+  var defaultData = typeof parentVal === 'function'
+    ? parentVal.call(vm)
+    : undefined
+  if (instanceData) {
+    // mix default data into instance data
+    for (var key in defaultData) {
+      if (!instanceData.hasOwnProperty(key)) {
+        instanceData.$add(key, defaultData[key])
+      }
+    }
+    return instanceData
+  } else {
+    return defaultData
+  }
+}
+
+/**
+ * El
+ */
+
+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
+  }
+  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.
+ */
+
+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
+    while (i--) {
+      field = keys[i]
+      ret[field] = parentVal[field]
+    }
+  }
+  if (childVal) extend(ret, childVal)
+  return ret
+}
+
+/**
+ * Events & Watchers.
+ *
+ * Events & watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+
+strats.watch =
+strats.events = function (parentVal, childVal) {
+  if (!childVal) return parentVal
+  if (!parentVal) return childVal
+  var ret = {}
+  extend(ret, parentVal)
+  for (var key in childVal) {
+    var parent = ret[key]
+    var child = childVal[key]
+    ret[key] = parent
+      ? parent.concat(child)
+      : [child]
+  }
+  return ret
+}
+
+/**
+ * Other object hashes.
+ */
+
+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
+}
+
+/**
+ * Default strategy.
+ */
+
+var defaultStrat = function (parentVal, childVal) {
+  return childVal === undefined
+    ? parentVal
+    : childVal
+}
+
+/**
+ * Make sure component options get converted to actual
+ * constructors.
+ *
+ * @param {Object} components
+ */
+
+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)
+      }
+    }
+  }
+}
+
+/**
+ * Merge two option objects into a new one.
+ * Core utility used in both instantiation and inheritance.
+ *
+ * @param {Object} parent
+ * @param {Object} child
+ * @param {Vue} [vm] - if vm is present, indicates this is
+ *                     an instantiation merge.
+ */
+
+module.exports = function mergeOptions (parent, child, vm) {
+  guardComponents(child.components)
+  var options = {}
+  var key
+  for (key in parent) {
+    merge(parent[key], child[key], key)
+  }
+  for (key in child) {
+    if (!(parent.hasOwnProperty(key))) {
+      merge(parent[key], child[key], key)
+    }
+  }
+  var mixins = child.mixins
+  if (mixins) {
+    for (var i = 0, l = mixins.length; i < l; i++) {
+      for (key in mixins[i]) {
+        merge(options[key], mixins[i][key], key)
+      }
+    }
+  }
+  function merge (parentVal, childVal, key) {
+    var strat = strats[key] || defaultStrat
+    options[key] = strat(parentVal, childVal, vm, key)
+  }
+  return options
+}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/utils.js b/vendor/assets/javascripts/bower/vue/src/utils.js
deleted file mode 100644
index 575cf37..0000000
--- a/vendor/assets/javascripts/bower/vue/src/utils.js
+++ /dev/null
@@ -1,326 +0,0 @@
-var config       = require('./config'),
-    toString     = ({}).toString,
-    win          = window,
-    console      = win.console,
-    def          = Object.defineProperty,
-    OBJECT       = 'object',
-    THIS_RE      = /[^\w]this[^\w]/,
-    BRACKET_RE_S = /\['([^']+)'\]/g,
-    BRACKET_RE_D = /\["([^"]+)"\]/g,
-    hasClassList = 'classList' in document.documentElement,
-    ViewModel // late def
-
-var defer =
-    win.requestAnimationFrame ||
-    win.webkitRequestAnimationFrame ||
-    win.setTimeout
-
-/**
- *  Normalize keypath with possible brackets into dot notations
- */
-function normalizeKeypath (key) {
-    return key.indexOf('[') < 0
-        ? key
-        : key.replace(BRACKET_RE_S, '.$1')
-             .replace(BRACKET_RE_D, '.$1')
-}
-
-var utils = module.exports = {
-
-    /**
-     *  Convert a string template to a dom fragment
-     */
-    toFragment: require('./fragment'),
-
-    /**
-     *  Parse the various types of template options
-     */
-    parseTemplateOption: require('./template-parser.js'),
-
-    /**
-     *  get a value from an object keypath
-     */
-    get: function (obj, key) {
-        /* jshint eqeqeq: false */
-        key = normalizeKeypath(key)
-        if (key.indexOf('.') < 0) {
-            return obj[key]
-        }
-        var path = key.split('.'),
-            d = -1, l = path.length
-        while (++d < l && obj != null) {
-            obj = obj[path[d]]
-        }
-        return obj
-    },
-
-    /**
-     *  set a value to an object keypath
-     */
-    set: function (obj, key, val) {
-        /* jshint eqeqeq: false */
-        key = normalizeKeypath(key)
-        if (key.indexOf('.') < 0) {
-            obj[key] = val
-            return
-        }
-        var path = key.split('.'),
-            d = -1, l = path.length - 1
-        while (++d < l) {
-            if (obj[path[d]] == null) {
-                obj[path[d]] = {}
-            }
-            obj = obj[path[d]]
-        }
-        obj[path[d]] = val
-    },
-
-    /**
-     *  return the base segment of a keypath
-     */
-    baseKey: function (key) {
-        return key.indexOf('.') > 0
-            ? key.split('.')[0]
-            : key
-    },
-
-    /**
-     *  Create a prototype-less object
-     *  which is a better hash/map
-     */
-    hash: function () {
-        return Object.create(null)
-    },
-
-    /**
-     *  get an attribute and remove it.
-     */
-    attr: function (el, type) {
-        var attr = config.prefix + '-' + type,
-            val = el.getAttribute(attr)
-        if (val !== null) {
-            el.removeAttribute(attr)
-        }
-        return val
-    },
-
-    /**
-     *  Define an ienumerable property
-     *  This avoids it being included in JSON.stringify
-     *  or for...in loops.
-     */
-    defProtected: function (obj, key, val, enumerable, writable) {
-        def(obj, key, {
-            value        : val,
-            enumerable   : enumerable,
-            writable     : writable,
-            configurable : true
-        })
-    },
-
-    /**
-     *  A less bullet-proof but more efficient type check
-     *  than Object.prototype.toString
-     */
-    isObject: function (obj) {
-        return typeof obj === OBJECT && obj && !Array.isArray(obj)
-    },
-
-    /**
-     *  A more accurate but less efficient type check
-     */
-    isTrueObject: function (obj) {
-        return toString.call(obj) === '[object Object]'
-    },
-
-    /**
-     *  Most simple bind
-     *  enough for the usecase and fast than native bind()
-     */
-    bind: function (fn, ctx) {
-        return function (arg) {
-            return fn.call(ctx, arg)
-        }
-    },
-
-    /**
-     *  Make sure null and undefined output empty string
-     */
-    guard: function (value) {
-        /* jshint eqeqeq: false, eqnull: true */
-        return value == null
-            ? ''
-            : (typeof value == 'object')
-                ? JSON.stringify(value)
-                : value
-    },
-
-    /**
-     *  When setting value on the VM, parse possible numbers
-     */
-    checkNumber: function (value) {
-        return (isNaN(value) || value === null || typeof value === 'boolean')
-            ? value
-            : Number(value)
-    },
-
-    /**
-     *  simple extend
-     */
-    extend: function (obj, ext) {
-        for (var key in ext) {
-            if (obj[key] !== ext[key]) {
-                obj[key] = ext[key]
-            }
-        }
-        return obj
-    },
-
-    /**
-     *  filter an array with duplicates into uniques
-     */
-    unique: function (arr) {
-        var hash = utils.hash(),
-            i = arr.length,
-            key, res = []
-        while (i--) {
-            key = arr[i]
-            if (hash[key]) continue
-            hash[key] = 1
-            res.push(key)
-        }
-        return res
-    },
-
-    /**
-     *  Convert the object to a ViewModel constructor
-     *  if it is not already one
-     */
-    toConstructor: function (obj) {
-        ViewModel = ViewModel || require('./viewmodel')
-        return utils.isObject(obj)
-            ? ViewModel.extend(obj)
-            : typeof obj === 'function'
-                ? obj
-                : null
-    },
-
-    /**
-     *  Check if a filter function contains references to `this`
-     *  If yes, mark it as a computed filter.
-     */
-    checkFilter: function (filter) {
-        if (THIS_RE.test(filter.toString())) {
-            filter.computed = true
-        }
-    },
-
-    /**
-     *  convert certain option values to the desired format.
-     */
-    processOptions: function (options) {
-        var components = options.components,
-            partials   = options.partials,
-            template   = options.template,
-            filters    = options.filters,
-            key
-        if (components) {
-            for (key in components) {
-                components[key] = utils.toConstructor(components[key])
-            }
-        }
-        if (partials) {
-            for (key in partials) {
-                partials[key] = utils.parseTemplateOption(partials[key])
-            }
-        }
-        if (filters) {
-            for (key in filters) {
-                utils.checkFilter(filters[key])
-            }
-        }
-        if (template) {
-            options.template = utils.parseTemplateOption(template)
-        }
-    },
-
-    /**
-     *  used to defer batch updates
-     */
-    nextTick: function (cb) {
-        defer(cb, 0)
-    },
-
-    /**
-     *  add class for IE9
-     *  uses classList if available
-     */
-    addClass: function (el, cls) {
-        if (hasClassList) {
-            el.classList.add(cls)
-        } else {
-            var cur = ' ' + el.className + ' '
-            if (cur.indexOf(' ' + cls + ' ') < 0) {
-                el.className = (cur + cls).trim()
-            }
-        }
-    },
-
-    /**
-     *  remove class for IE9
-     */
-    removeClass: function (el, cls) {
-        if (hasClassList) {
-            el.classList.remove(cls)
-        } else {
-            var cur = ' ' + el.className + ' ',
-                tar = ' ' + cls + ' '
-            while (cur.indexOf(tar) >= 0) {
-                cur = cur.replace(tar, ' ')
-            }
-            el.className = cur.trim()
-        }
-    },
-
-    /**
-     *  Convert an object to Array
-     *  used in v-repeat and array filters
-     */
-    objectToArray: function (obj) {
-        var res = [], val, data
-        for (var key in obj) {
-            val = obj[key]
-            data = utils.isObject(val)
-                ? val
-                : { $value: val }
-            data.$key = key
-            res.push(data)
-        }
-        return res
-    }
-}
-
-enableDebug()
-function enableDebug () {
-    /**
-     *  log for debugging
-     */
-    utils.log = function (msg) {
-        if (config.debug && console) {
-            console.log(msg)
-        }
-    }
-    
-    /**
-     *  warnings, traces by default
-     *  can be suppressed by `silent` option.
-     */
-    utils.warn = function (msg) {
-        if (!config.silent && console) {
-            console.warn(msg)
-            if (config.debug && console.trace) {
-                console.trace()
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/viewmodel.js b/vendor/assets/javascripts/bower/vue/src/viewmodel.js
deleted file mode 100644
index b523ff6..0000000
--- a/vendor/assets/javascripts/bower/vue/src/viewmodel.js
+++ /dev/null
@@ -1,190 +0,0 @@
-var Compiler   = require('./compiler'),
-    utils      = require('./utils'),
-    transition = require('./transition'),
-    Batcher    = require('./batcher'),
-    slice      = [].slice,
-    def        = utils.defProtected,
-    nextTick   = utils.nextTick,
-
-    // batch $watch callbacks
-    watcherBatcher = new Batcher(),
-    watcherId      = 1
-
-/**
- *  ViewModel exposed to the user that holds data,
- *  computed properties, event handlers
- *  and a few reserved methods
- */
-function ViewModel (options) {
-    // compile if options passed, if false return. options are passed directly to compiler
-    if (options === false) return
-    new Compiler(this, options)
-}
-
-// All VM prototype methods are inenumerable
-// so it can be stringified/looped through as raw data
-var VMProto = ViewModel.prototype
-
-/**
- *  init allows config compilation after instantiation:
- *    var a = new Vue(false)
- *    a.init(config)
- */
-def(VMProto, '$init', function (options) {
-    new Compiler(this, options)
-})
-
-/**
- *  Convenience function to get a value from
- *  a keypath
- */
-def(VMProto, '$get', function (key) {
-    var val = utils.get(this, key)
-    return val === undefined && this.$parent
-        ? this.$parent.$get(key)
-        : val
-})
-
-/**
- *  Convenience function to set an actual nested value
- *  from a flat key string. Used in directives.
- */
-def(VMProto, '$set', function (key, value) {
-    utils.set(this, key, value)
-})
-
-/**
- *  watch a key on the viewmodel for changes
- *  fire callback with new value
- */
-def(VMProto, '$watch', function (key, callback) {
-    // save a unique id for each watcher
-    var id = watcherId++,
-        self = this
-    function on () {
-        var args = slice.call(arguments)
-        watcherBatcher.push({
-            id: id,
-            override: true,
-            execute: function () {
-                callback.apply(self, args)
-            }
-        })
-    }
-    callback._fn = on
-    self.$compiler.observer.on('change:' + key, on)
-})
-
-/**
- *  unwatch a key
- */
-def(VMProto, '$unwatch', function (key, callback) {
-    // workaround here
-    // since the emitter module checks callback existence
-    // by checking the length of arguments
-    var args = ['change:' + key],
-        ob = this.$compiler.observer
-    if (callback) args.push(callback._fn)
-    ob.off.apply(ob, args)
-})
-
-/**
- *  unbind everything, remove everything
- */
-def(VMProto, '$destroy', function (noRemove) {
-    this.$compiler.destroy(noRemove)
-})
-
-/**
- *  broadcast an event to all child VMs recursively.
- */
-def(VMProto, '$broadcast', function () {
-    var children = this.$compiler.children,
-        i = children.length,
-        child
-    while (i--) {
-        child = children[i]
-        child.emitter.applyEmit.apply(child.emitter, arguments)
-        child.vm.$broadcast.apply(child.vm, arguments)
-    }
-})
-
-/**
- *  emit an event that propagates all the way up to parent VMs.
- */
-def(VMProto, '$dispatch', function () {
-    var compiler = this.$compiler,
-        emitter = compiler.emitter,
-        parent = compiler.parent
-    emitter.applyEmit.apply(emitter, arguments)
-    if (parent) {
-        parent.vm.$dispatch.apply(parent.vm, arguments)
-    }
-})
-
-/**
- *  delegate on/off/once to the compiler's emitter
- */
-;['emit', 'on', 'off', 'once'].forEach(function (method) {
-    // internal emit has fixed number of arguments.
-    // exposed emit uses the external version
-    // with fn.apply.
-    var realMethod = method === 'emit'
-        ? 'applyEmit'
-        : method
-    def(VMProto, '$' + method, function () {
-        var emitter = this.$compiler.emitter
-        emitter[realMethod].apply(emitter, arguments)
-    })
-})
-
-// DOM convenience methods
-
-def(VMProto, '$appendTo', function (target, cb) {
-    target = query(target)
-    var el = this.$el
-    transition(el, 1, function () {
-        target.appendChild(el)
-        if (cb) nextTick(cb)
-    }, this.$compiler)
-})
-
-def(VMProto, '$remove', function (cb) {
-    var el = this.$el
-    transition(el, -1, function () {
-        if (el.parentNode) {
-            el.parentNode.removeChild(el)
-        }
-        if (cb) nextTick(cb)
-    }, this.$compiler)
-})
-
-def(VMProto, '$before', function (target, cb) {
-    target = query(target)
-    var el = this.$el
-    transition(el, 1, function () {
-        target.parentNode.insertBefore(el, target)
-        if (cb) nextTick(cb)
-    }, this.$compiler)
-})
-
-def(VMProto, '$after', function (target, cb) {
-    target = query(target)
-    var el = this.$el
-    transition(el, 1, function () {
-        if (target.nextSibling) {
-            target.parentNode.insertBefore(el, target.nextSibling)
-        } else {
-            target.parentNode.appendChild(el)
-        }
-        if (cb) nextTick(cb)
-    }, this.$compiler)
-})
-
-function query (el) {
-    return typeof el === 'string'
-        ? document.querySelector(el)
-        : el
-}
-
-module.exports = ViewModel
diff --git a/vendor/assets/javascripts/bower/vue/src/vue.js b/vendor/assets/javascripts/bower/vue/src/vue.js
new file mode 100644
index 0000000..37f0f91
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/vue.js
@@ -0,0 +1,84 @@
+var _ = require('./util')
+var extend = _.extend
+
+/**
+ * The exposed Vue constructor.
+ *
+ * API conventions:
+ * - public API methods/properties are prefiexed with `$`
+ * - internal methods/properties are prefixed with `_`
+ * - non-prefixed properties are assumed to be proxied user
+ *   data.
+ *
+ * @constructor
+ * @param {Object} [options]
+ * @public
+ */
+
+function Vue (options) {
+  this._init(options)
+}
+
+/**
+ * Mixin global API
+ */
+
+extend(Vue, require('./api/global'))
+
+/**
+ * Vue and every constructor that extends Vue has an
+ * associated options object, which can be accessed during
+ * compilation steps as `this.constructor.options`.
+ *
+ * These can be seen as the default options of every
+ * Vue instance.
+ */
+
+Vue.options = {
+  directives  : require('./directives'),
+  filters     : require('./filters'),
+  partials    : {},
+  transitions : {},
+  components  : {}
+}
+
+/**
+ * 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)
+  }
+})
+
+/**
+ * Mixin internal instance methods
+ */
+
+extend(p, require('./instance/init'))
+extend(p, require('./instance/events'))
+extend(p, require('./instance/scope'))
+extend(p, require('./instance/compile'))
+
+/**
+ * Mixin public API methods
+ */
+
+extend(p, require('./api/data'))
+extend(p, require('./api/dom'))
+extend(p, require('./api/events'))
+extend(p, require('./api/child'))
+extend(p, require('./api/lifecycle'))
+
+module.exports = _.Vue = Vue
\ No newline at end of file
diff --git a/vendor/assets/javascripts/bower/vue/src/watcher.js b/vendor/assets/javascripts/bower/vue/src/watcher.js
new file mode 100644
index 0000000..24892e1
--- /dev/null
+++ b/vendor/assets/javascripts/bower/vue/src/watcher.js
@@ -0,0 +1,215 @@
+var _ = require('./util')
+var config = require('./config')
+var Observer = require('./observer')
+var expParser = require('./parse/expression')
+var Batcher = require('./batcher')
+
+var batcher = new Batcher()
+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.
+ *
+ * @param {Vue} vm
+ * @param {String} expression
+ * @param {Function} cb
+ * @param {Array} [filters]
+ * @param {Boolean} [needSet]
+ * @param {Boolean} [deep]
+ * @constructor
+ */
+
+function Watcher (vm, expression, cb, filters, needSet, deep) {
+  this.vm = vm
+  vm._watcherList.push(this)
+  this.expression = expression
+  this.cbs = [cb]
+  this.id = ++uid // uid for batching
+  this.active = true
+  this.deep = deep
+  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.
+  this.readFilters = filters && filters.read
+  this.writeFilters = filters && filters.write
+  // parse expression for getter/setter
+  var res = expParser.parse(expression, needSet)
+  this.getter = res.get
+  this.setter = res.set
+  this.value = this.get()
+}
+
+var p = Watcher.prototype
+
+/**
+ * Add a binding dependency to this directive.
+ *
+ * @param {Binding} binding
+ */
+
+p.addDep = function (binding) {
+  var id = binding.id
+  if (!this.newDeps[id]) {
+    this.newDeps[id] = binding
+    if (!this.deps[id]) {
+      this.deps[id] = binding
+      binding.addSub(this)
+    }
+  }
+}
+
+/**
+ * Evaluate the getter, and re-collect dependencies.
+ */
+
+p.get = function () {
+  this.beforeGet()
+  var vm = this.vm
+  var value
+  try {
+    value = this.getter.call(vm, vm)
+  } catch (e) {}
+  // use JSON.stringify to "touch" every property
+  // so they are all tracked as dependencies for
+  // deep watching
+  if (this.deep) JSON.stringify(value)
+  value = _.applyFilters(value, this.readFilters, vm)
+  this.afterGet()
+  return value
+}
+
+/**
+ * Set the corresponding value with the setter.
+ *
+ * @param {*} value
+ */
+
+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) {}
+}
+
+/**
+ * Prepare for dependency collection.
+ */
+
+p.beforeGet = function () {
+  Observer.target = this
+  this.newDeps = {}
+}
+
+/**
+ * Clean up for dependency collection.
+ */
+
+p.afterGet = function () {
+  Observer.target = null
+  for (var id in this.deps) {
+    if (!this.newDeps[id]) {
+      this.deps[id].removeSub(this)
+    }
+  }
+  this.deps = this.newDeps
+}
+
+/**
+ * Subscriber interface.
+ * Will be called when a dependency changes.
+ */
+
+p.update = function () {
+  if (config.async) {
+    batcher.push(this)
+  } else {
+    this.run()
+  }
+}
+
+/**
+ * Batcher job interface.
+ * Will be called by the batcher.
+ */
+
+p.run = function () {
+  if (this.active) {
+    var value = this.get()
+    if (
+      (typeof value === 'object' && value !== null) ||
+      value !== this.value
+    ) {
+      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
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 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) {
+    var i = cbs.indexOf(cb)
+    if (i > -1) {
+      cbs.splice(i, 1)
+    }
+  } else if (cb === cbs[0]) {
+    this.teardown()
+  }
+}
+
+/**
+ * Remove self from all dependencies' subcriber list.
+ */
+
+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) {
+      var list = this.vm._watcherList
+      list.splice(list.indexOf(this))
+    }
+    for (var id in this.deps) {
+      this.deps[id].removeSub(this)
+    }
+    this.active = false
+    this.vm = this.cbs = this.value = null
+  }
+}
+
+module.exports = Watcher
\ No newline at end of file