From 1db31dbe4660ed893f1bf4eb2545b1c52ef0725b Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 11 Jul 2016 19:14:29 +0300
Subject: [PATCH 01/90] Added vue.js as a lib.

---
 app/assets/javascripts/lib/vue.js | 10073 ++++++++++++++++++++++++++++
 1 file changed, 10073 insertions(+)
 create mode 100644 app/assets/javascripts/lib/vue.js

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

From 907317c457754db691a88a77845121ac517917d5 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 11 Jul 2016 19:16:42 +0300
Subject: [PATCH 02/90] Added routes for conflicts in merge requests page.

---
 app/controllers/projects/merge_requests_controller.rb | 11 +++++++++--
 app/helpers/nav_helper.rb                             |  1 +
 config/routes.rb                                      |  1 +
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 139680d2df9..4fa7d971013 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -9,11 +9,11 @@ class Projects::MergeRequestsController < Projects::ApplicationController
 
   before_action :module_enabled
   before_action :merge_request, only: [
-    :edit, :update, :show, :diffs, :commits, :builds, :merge, :merge_check,
+    :edit, :update, :show, :diffs, :commits, :conflicts, :builds, :merge, :merge_check,
     :ci_status, :toggle_subscription, :cancel_merge_when_build_succeeds, :remove_wip
   ]
   before_action :validates_merge_request, only: [:show, :diffs, :commits, :builds]
-  before_action :define_show_vars, only: [:show, :diffs, :commits, :builds]
+  before_action :define_show_vars, only: [:show, :diffs, :commits, :conflicts, :builds]
   before_action :define_widget_vars, only: [:merge, :cancel_merge_when_build_succeeds, :merge_check]
   before_action :define_commit_vars, only: [:diffs]
   before_action :define_diff_comment_vars, only: [:diffs]
@@ -130,6 +130,13 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     end
   end
 
+
+  def conflicts
+    respond_to do |format|
+      format.html { render 'show' }
+    end
+  end
+
   def builds
     respond_to do |format|
       format.html do
diff --git a/app/helpers/nav_helper.rb b/app/helpers/nav_helper.rb
index 3ff8be5e284..6c1cc6ef072 100644
--- a/app/helpers/nav_helper.rb
+++ b/app/helpers/nav_helper.rb
@@ -24,6 +24,7 @@ module NavHelper
       current_path?('merge_requests#diffs') ||
       current_path?('merge_requests#commits') ||
       current_path?('merge_requests#builds') ||
+      current_path?('merge_requests#conflicts') ||
       current_path?('issues#show')
       if cookies[:collapsed_gutter] == 'true'
         "page-gutter right-sidebar-collapsed"
diff --git a/config/routes.rb b/config/routes.rb
index 9a98fab15a3..7df9726bc8e 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -718,6 +718,7 @@ Rails.application.routes.draw do
           member do
             get :commits
             get :diffs
+            get :conflicts
             get :builds
             get :merge_check
             post :merge

From 774434f443ca9c13292f041104c1cc708cf364f9 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 11 Jul 2016 19:16:58 +0300
Subject: [PATCH 03/90] Added dummy merge conflicts data.

---
 .../javascripts/merge_conflicts_data.coffee   | 95 +++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 app/assets/javascripts/merge_conflicts_data.coffee

diff --git a/app/assets/javascripts/merge_conflicts_data.coffee b/app/assets/javascripts/merge_conflicts_data.coffee
new file mode 100644
index 00000000000..a489cab7ba6
--- /dev/null
+++ b/app/assets/javascripts/merge_conflicts_data.coffee
@@ -0,0 +1,95 @@
+window.mergeConflictsData = {
+  "target_branch": "master",
+  "source_branch": "mc-ui",
+  "files": [
+    {
+      "commit_sha": "b5fa56eb3f2cea5e21c68b43c7c22b5b96e0e7b3",
+      "old_path": "lib/component.js",
+      "new_path": "lib/component.js",
+      "sections": [
+        {
+          "conflict": false,
+          "lines": [
+            {
+              "type": null,
+              "old_line": 206,
+              "new_line": 206,
+              "text": ""
+            },
+            {
+              "type": null,
+              "old_line": 207,
+              "new_line": 207,
+              "text": "var options = utils.merge.apply(utils, args);"
+            }
+          ]
+        },
+        {
+          "conflict": true,
+          "id": "section-id-123",
+          "lines": [
+            {
+              "type": "old",
+              "old_line": 208,
+              "new_line": null,
+              "text": "$(selector).each(function(i, rawNode) {"
+            },
+            {
+              "type": "old",
+              "old_line": 209,
+              "new_line": null,
+              "text": "var componentInfo = registry.findComponentInfo(this)"
+            },
+            {
+              "type": "old",
+              "old_line": 210,
+              "new_line": null,
+              "text": "if (componentInfo && componentInfo.isAttachedTo(rawNode)) {"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 208,
+              "text": "$(selector).each(function(i, node) {"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 209,
+              "text": "if (componentInfo && componentInfo.isAttachedTo(node)) {"
+            }
+          ]
+        },
+        {
+          "conflict": false,
+          "lines": [
+            {
+              "type": null,
+              "old_line": 211,
+              "new_line": 210,
+              "text": "return;"
+            },
+            {
+              "type": null,
+              "old_line": 212,
+              "new_line": 211,
+              "text": "}"
+            },
+            {
+              "type": null,
+              "old_line": null,
+              "new_line": 212,
+              "text": ""
+            },
+            {
+              "type": null,
+              "old_line": 213,
+              "new_line": 213,
+              "text": ""
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

From 1fbd6a967c1ada9f1301c9d8106de5773d060682 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 11 Jul 2016 19:17:24 +0300
Subject: [PATCH 04/90] Added new Conflicts tab and conflicts placeholder to
 MRs page.

---
 app/views/projects/merge_requests/_show.html.haml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/app/views/projects/merge_requests/_show.html.haml b/app/views/projects/merge_requests/_show.html.haml
index 269198adf91..e5683d5a987 100644
--- a/app/views/projects/merge_requests/_show.html.haml
+++ b/app/views/projects/merge_requests/_show.html.haml
@@ -61,6 +61,10 @@
           = link_to diffs_namespace_project_merge_request_path(@project.namespace, @project, @merge_request), data: {target: 'div#diffs', action: 'diffs', toggle: 'tab'} do
             Changes
             %span.badge= @merge_request.diff_size
+        %li.conflicts-tab
+          = link_to conflicts_namespace_project_merge_request_path(@project.namespace, @project, @merge_request), data: {target: 'div#conflicts', action: 'conflicts', toggle: 'tab'} do
+            Conflicts
+            %span.badge 3
 
       .tab-content
         #notes.notes.tab-pane.voting_notes
@@ -78,6 +82,9 @@
           - # This tab is always loaded via AJAX
         #diffs.diffs.tab-pane
           - # This tab is always loaded via AJAX
+        #conflicts.conflicts.tab-pane
+          - # This tab is always loaded via AJAX
+          = render 'projects/merge_requests/show/conflicts'
 
       .mr-loading-status
         = spinner

From d438230a24712873204a2d6b334ae53e6e83f66e Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 11 Jul 2016 19:18:28 +0300
Subject: [PATCH 05/90] Make resolve these conflicts text a link to conflicts
 tab.

---
 .../projects/merge_requests/widget/open/_conflicts.html.haml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
index f000cc38a65..6bdbbb94f09 100644
--- a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
@@ -3,7 +3,10 @@
   This merge request contains merge conflicts
 
 %p
-  Please resolve these conflicts or
+  Please
+  = link_to conflicts_namespace_project_merge_request_path(@project.namespace, @project, @merge_request) do
+    resolve these conflicts
+  or
   - if @merge_request.can_be_merged_via_command_line_by?(current_user)
     #{link_to "merge this request manually", "#modal_merge_info", class: "how_to_merge_link vlink", "data-toggle" => "modal"}.
   - else

From 9d70a4ba769d7d0c652e37dc0341f5230b125fc8 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Tue, 12 Jul 2016 01:08:04 +0300
Subject: [PATCH 06/90] Added new UI components for Merge Conflicts UI.

---
 .../merge_conflict_resolver.js.coffee         | 105 ++++++++++++++++++
 app/assets/stylesheets/behaviors.scss         |   5 +
 .../stylesheets/pages/merge_conflicts.scss    |  66 +++++++++++
 .../merge_requests/show/_conflicts.html.haml  |  83 ++++++++++++++
 4 files changed, 259 insertions(+)
 create mode 100644 app/assets/javascripts/merge_conflict_resolver.js.coffee
 create mode 100644 app/assets/stylesheets/pages/merge_conflicts.scss
 create mode 100644 app/views/projects/merge_requests/show/_conflicts.html.haml

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.coffee b/app/assets/javascripts/merge_conflict_resolver.js.coffee
new file mode 100644
index 00000000000..725ff8560ea
--- /dev/null
+++ b/app/assets/javascripts/merge_conflict_resolver.js.coffee
@@ -0,0 +1,105 @@
+#= require lib/vue
+
+class window.MergeConflictResolver extends Vue
+
+  constructor: (options = {}) ->
+
+    options.el      = '#conflicts'
+    options.data    = @getInitialData()
+    options.created = -> @fetchData()
+    options.name    = 'MergeConflictResolver'
+
+    super options
+
+    window.v = this
+
+
+  fetchData: ->
+
+    $.ajax
+      url    : '/emojis'
+      success: (response) =>
+        @handleResponse window.mergeConflictsData
+
+
+  handleResponse: (data) ->
+
+    @isLoading     = no
+    @conflictsData = @decorateData data
+
+
+  handleViewTypeChange: (newType) ->
+
+    return if newType is @diffView
+    return unless newType in [ 'parallel', 'inline' ]
+
+    @diffView = newType
+    $.cookie 'diff_view', newType
+    @isParallel = @diffView is 'parallel'
+
+    # FIXME: Maybe even better with vue.js
+    $('.container-fluid').toggleClass 'container-limited'
+
+
+  handleSelected: (sectionId, selection) ->
+
+    console.log sectionId, selection
+
+
+  decorateData: (data) ->
+
+    for file in data.files
+      file.parallelLines = { left: [], right: [] }
+      file.inlineLines   = []
+      currentLineType    = 'old'
+
+      for section in file.sections
+        { conflict, lines, id } = section
+
+        if conflict
+          header = { lineType: 'header', id }
+          file.parallelLines.left.push  header
+          file.parallelLines.right.push header
+
+          header.type = 'old'
+          file.inlineLines.push header
+
+        for line in lines
+          if line.type in ['new', 'old'] and currentLineType isnt line.type
+            currentLineType = line.type
+            # FIXME: Find a better way to add a new line
+            file.inlineLines.push { lineType: 'emptyLine', text: '<span> </span>' }
+
+          line.conflict = conflict
+          file.inlineLines.push line
+
+          if conflict
+            if line.type is 'old'
+              line = { lineType: 'conflict', lineNumber: line.old_line, text: line.text }
+              file.parallelLines.left.push  line
+            else if line.type is 'new'
+              line = { lineType: 'conflict', lineNumber: line.new_line, text: line.text }
+              file.parallelLines.right.push line
+            else
+              console.log 'unhandled line type...', line
+          else
+            file.parallelLines.left.push  { lineType: 'context', lineNumber: line.old_line, text: line.text }
+            file.parallelLines.right.push { lineType: 'context', lineNumber: line.new_line, text: line.text }
+
+        if conflict
+          file.inlineLines.push { lineType: 'header', id, type: 'new' }
+
+    console.log data
+    return data
+
+
+  getInitialData: ->
+
+    diffViewType = $.cookie 'diff_view'
+
+    return {
+      isLoading     : yes
+      diffView      : diffViewType
+      conflictsData : {}
+      isParallel    : diffViewType is 'parallel'
+    }
diff --git a/app/assets/stylesheets/behaviors.scss b/app/assets/stylesheets/behaviors.scss
index 542a53f0377..a6b9efc49c9 100644
--- a/app/assets/stylesheets/behaviors.scss
+++ b/app/assets/stylesheets/behaviors.scss
@@ -20,3 +20,8 @@
     .turn-off { display: block; }
   }
 }
+
+
+[v-cloak] {
+  display: none;
+}
diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
new file mode 100644
index 00000000000..6e77fc1c2e3
--- /dev/null
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -0,0 +1,66 @@
+$head_line:               #EFFDEB;
+$head_header:             #DAFACE;
+$head_header_selected:    #BAF0A8;
+
+$origin_line:             #F2F9FF;
+$origin_header:           #E0F0FF;
+$origin_header_selected:  #ADD8FF;
+
+
+#conflicts {
+
+  .diff-wrap-lines .line_content {
+    white-space: normal;
+  }
+
+  .head {
+    .header, .diff-line-num {
+      background-color: $head_header;
+    }
+    td {
+      background-color: $head_line;
+    }
+  }
+
+  .origin {
+    .header, .diff-line-num {
+      background-color: $origin_header;
+    }
+    td {
+      background-color: $origin_line;
+    }
+  }
+
+  .parallel-view {
+    .diff-content {
+      overflow: hidden;
+      table {
+        width: 50%;
+        float: left;
+      }
+    }
+  }
+
+  .parallel .header {
+    button {
+      right: 10px;
+    }
+  }
+
+  .line_content.header {
+    position: relative;
+
+    button {
+      border-radius: 4px;
+      border: 1px solid #E1E1E1;
+      background: #FFF;
+      font-size: 10px;
+      position: absolute;
+      right: 20px;
+      height: 17px;
+      line-height: 4px; // FIXME: 4px?
+      top: 1px;
+      outline: none;
+    }
+  }
+}
diff --git a/app/views/projects/merge_requests/show/_conflicts.html.haml b/app/views/projects/merge_requests/show/_conflicts.html.haml
new file mode 100644
index 00000000000..5386de86a1c
--- /dev/null
+++ b/app/views/projects/merge_requests/show/_conflicts.html.haml
@@ -0,0 +1,83 @@
+.loading{ "v-if" => "isLoading" }
+  %i.fa.fa-spinner.fa-spin
+
+.content-block.oneline-block.files-changed{ "v-if" => "!isLoading" }
+  .inline-parallel-buttons
+    .btn-group
+      %a.btn{ |
+        ":class" => "{'active': !isParallel}", |
+        "@click" => "handleViewTypeChange('inline')"}
+        Inline
+      %a.btn{ |
+        ":class" => "{'active': isParallel}", |
+        "@click" => "handleViewTypeChange('parallel')"}
+        Side-by-side
+
+  .js-toggle-container
+    .commit-stat-summary
+      Showing
+      %strong.cred 3 conflicts
+      for
+      %strong {{conflictsData.source_branch}}
+      into
+      %strong {{conflictsData.target_branch}}
+
+
+.files-wrapper{ "v-if" => "!isLoading" }
+  .files{{"v-if" => "isParallel"}}
+    .diff-file.file-holder.conflict.unresolved.parallel-view{"v-for" => "file in conflictsData.files"}
+      .file-title
+        %i.fa.fa-ban
+        %a
+          %span {{file.new_path}}
+        .file-actions
+          %a.btn.btn-sm View file @{{file.commit_sha.slice(0, 7)}}
+
+      .diff-content.diff-wrap-lines
+        .diff-wrap-lines.code.file-content.js-syntax-highlight.white
+          %table{"v-for" => "(key, group) in file.parallelLines"}
+            %tr.line_holder.parallel{ |
+              "v-for" => "line in group", |
+              ":class" => "line.lineType != 'context' && (key == 'left' ? 'head' : 'origin')"}
+
+              %td.diff-line-num.header{"v-if" => "line.lineType == 'header'"}
+              %td.line_content.header{"v-if" => "line.lineType == 'header'"}
+                %strong {{key == 'left' ? 'HEAD//our changes' : 'origin//their changes'}}
+                %button.btn{"@click" => "handleSelected(line.id, line.lineType)"} Use this
+
+              %td.diff-line-num.old_line{"v-if" => "line.lineType != 'header'"}
+                {{line.lineNumber}}
+              %td.line_content{"v-if" => "line.lineType != 'header'"}
+                {{line.text}}
+
+
+  .files{{"v-if" => "!isParallel"}}
+    .diff-file.file-holder.conflict.unresolved.inline-view{"v-for" => "file in conflictsData.files"}
+      .file-title
+        %i.fa.fa-ban
+        %a
+          %span {{file.new_path}}
+        .file-actions
+          %a.btn.btn-sm View file @{{file.commit_sha.slice(0, 7)}}
+
+      .diff-content.diff-wrap-lines
+        .diff-wrap-lines.code.file-content.js-syntax-highlight.white
+          %table
+            %tr.line_holder{ |
+              "v-for" => "line in file.inlineLines", |
+              ":class" => "line.type == 'old' ? 'head' : line.type == 'new' ? 'origin' : ''"}
+
+              %template{"v-if" => "line.lineType != 'header'"}
+                %td.diff-line-num.old_line
+                  %a {{line.old_line}}
+                %td.diff-line-num.new_line
+                  %a {{line.new_line}}
+                %td.line_content
+                  {{{line.text}}}
+
+              %template{"v-if" => "line.lineType == 'header'"}
+                %td.diff-line-num.header
+                %td.diff-line-num.header
+                %td.line_content.header
+                  %strong {{line.type == 'old' ? 'HEAD//our changes' : 'origin//their changes'}}
+                  %button.btn{"@click" => "handleSelected(line.id, line.type)"} Use this

From 4931a836727fb4986fb03c885c2cfcea28a4767e Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Tue, 12 Jul 2016 17:21:51 +0300
Subject: [PATCH 07/90] Improvements to simplify vue template.

---
 .../merge_conflict_resolver.js.coffee         | 26 +++++++-------
 .../merge_requests/show/_conflicts.html.haml  | 36 +++++++++----------
 2 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.coffee b/app/assets/javascripts/merge_conflict_resolver.js.coffee
index 725ff8560ea..6a79212b04a 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.coffee
+++ b/app/assets/javascripts/merge_conflict_resolver.js.coffee
@@ -48,21 +48,23 @@ class window.MergeConflictResolver extends Vue
 
   decorateData: (data) ->
 
+    headHeaderText   = 'HEAD//our changes'
+    originHeaderText = 'origin//their changes'
+
     for file in data.files
-      file.parallelLines = { left: [], right: [] }
-      file.inlineLines   = []
-      currentLineType    = 'old'
+      file.parallelLines  = { left: [], right: [] }
+      file.inlineLines    = []
+      file.shortCommitSha = file.commit_sha.slice 0, 7
+      currentLineType     = 'old'
 
       for section in file.sections
         { conflict, lines, id } = section
 
         if conflict
-          header = { lineType: 'header', id }
-          file.parallelLines.left.push  header
-          file.parallelLines.right.push header
+          file.parallelLines.left.push  { isHeader: yes, id, text: headHeaderText, cssClass: 'head' }
+          file.parallelLines.right.push { isHeader: yes, id, text: originHeaderText, cssClass: 'origin' }
 
-          header.type = 'old'
-          file.inlineLines.push header
+          file.inlineLines.push { isHeader: yes, id, text: headHeaderText, type: 'old', cssClass: 'head' }
 
         for line in lines
           if line.type in ['new', 'old'] and currentLineType isnt line.type
@@ -71,14 +73,15 @@ class window.MergeConflictResolver extends Vue
             file.inlineLines.push { lineType: 'emptyLine', text: '<span> </span>' }
 
           line.conflict = conflict
+          line.cssClass = if line.type is 'old' then 'head' else if line.type is 'new' then 'origin' else ''
           file.inlineLines.push line
 
           if conflict
             if line.type is 'old'
-              line = { lineType: 'conflict', lineNumber: line.old_line, text: line.text }
+              line = { lineType: 'conflict', lineNumber: line.old_line, text: line.text, cssClass: 'head' }
               file.parallelLines.left.push  line
             else if line.type is 'new'
-              line = { lineType: 'conflict', lineNumber: line.new_line, text: line.text }
+              line = { lineType: 'conflict', lineNumber: line.new_line, text: line.text, cssClass: 'origin' }
               file.parallelLines.right.push line
             else
               console.log 'unhandled line type...', line
@@ -87,9 +90,8 @@ class window.MergeConflictResolver extends Vue
             file.parallelLines.right.push { lineType: 'context', lineNumber: line.new_line, text: line.text }
 
         if conflict
-          file.inlineLines.push { lineType: 'header', id, type: 'new' }
+          file.inlineLines.push { isHeader: yes, id, type: 'new', text: originHeaderText, cssClass: 'origin' }
 
-    console.log data
     return data
 
 
diff --git a/app/views/projects/merge_requests/show/_conflicts.html.haml b/app/views/projects/merge_requests/show/_conflicts.html.haml
index 5386de86a1c..fe415c1cfed 100644
--- a/app/views/projects/merge_requests/show/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/show/_conflicts.html.haml
@@ -31,24 +31,24 @@
         %a
           %span {{file.new_path}}
         .file-actions
-          %a.btn.btn-sm View file @{{file.commit_sha.slice(0, 7)}}
+          %a.btn.btn-sm View file @{{file.shortCommitSha}}
 
       .diff-content.diff-wrap-lines
         .diff-wrap-lines.code.file-content.js-syntax-highlight.white
           %table{"v-for" => "(key, group) in file.parallelLines"}
-            %tr.line_holder.parallel{ |
-              "v-for" => "line in group", |
-              ":class" => "line.lineType != 'context' && (key == 'left' ? 'head' : 'origin')"}
+            %tr.line_holder.parallel{"v-for" => "line in group", ":class" => "line.cssClass"}
 
-              %td.diff-line-num.header{"v-if" => "line.lineType == 'header'"}
-              %td.line_content.header{"v-if" => "line.lineType == 'header'"}
-                %strong {{key == 'left' ? 'HEAD//our changes' : 'origin//their changes'}}
-                %button.btn{"@click" => "handleSelected(line.id, line.lineType)"} Use this
+              %template{"v-if" => "line.isHeader"}
+                %td.diff-line-num.header
+                %td.line_content.header
+                  %strong {{line.text}}
+                  %button.btn{"@click" => "handleSelected(line.id, line.lineType)"} Use this
 
-              %td.diff-line-num.old_line{"v-if" => "line.lineType != 'header'"}
-                {{line.lineNumber}}
-              %td.line_content{"v-if" => "line.lineType != 'header'"}
-                {{line.text}}
+              %template{"v-if" => "!line.isHeader"}
+                %td.diff-line-num.old_line
+                  {{line.lineNumber}}
+                %td.line_content
+                  {{line.text}}
 
 
   .files{{"v-if" => "!isParallel"}}
@@ -58,16 +58,14 @@
         %a
           %span {{file.new_path}}
         .file-actions
-          %a.btn.btn-sm View file @{{file.commit_sha.slice(0, 7)}}
+          %a.btn.btn-sm View file @{{file.shortCommitSha}}
 
       .diff-content.diff-wrap-lines
         .diff-wrap-lines.code.file-content.js-syntax-highlight.white
           %table
-            %tr.line_holder{ |
-              "v-for" => "line in file.inlineLines", |
-              ":class" => "line.type == 'old' ? 'head' : line.type == 'new' ? 'origin' : ''"}
+            %tr.line_holder{"v-for" => "line in file.inlineLines", ":class" => "line.cssClass"}
 
-              %template{"v-if" => "line.lineType != 'header'"}
+              %template{"v-if" => "!line.isHeader"}
                 %td.diff-line-num.old_line
                   %a {{line.old_line}}
                 %td.diff-line-num.new_line
@@ -75,9 +73,9 @@
                 %td.line_content
                   {{{line.text}}}
 
-              %template{"v-if" => "line.lineType == 'header'"}
+              %template{"v-if" => "line.isHeader"}
                 %td.diff-line-num.header
                 %td.diff-line-num.header
                 %td.line_content.header
-                  %strong {{line.type == 'old' ? 'HEAD//our changes' : 'origin//their changes'}}
+                  %strong {{line.text}}
                   %button.btn{"@click" => "handleSelected(line.id, line.type)"} Use this

From c277681e8004d9a26451bad443ad00541a802ab9 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Wed, 13 Jul 2016 03:06:34 +0300
Subject: [PATCH 08/90] Update dummy data.

---
 .../javascripts/merge_conflicts_data.coffee   | 312 +++++++++++++++++-
 1 file changed, 311 insertions(+), 1 deletion(-)

diff --git a/app/assets/javascripts/merge_conflicts_data.coffee b/app/assets/javascripts/merge_conflicts_data.coffee
index a489cab7ba6..a302424f421 100644
--- a/app/assets/javascripts/merge_conflicts_data.coffee
+++ b/app/assets/javascripts/merge_conflicts_data.coffee
@@ -26,7 +26,7 @@ window.mergeConflictsData = {
         },
         {
           "conflict": true,
-          "id": "section-id-123",
+          "id": "section123",
           "lines": [
             {
               "type": "old",
@@ -90,6 +90,316 @@ window.mergeConflictsData = {
           ]
         }
       ]
+    },
+    {
+      "commit_sha": "b5fa56eb3f2cea5e21c68b43c7c22b5b96e0e7b3",
+      "old_path": "lib/component.js",
+      "new_path": "lib/component.js",
+      "sections": [
+        {
+          "conflict": false,
+          "lines": [
+            {
+              "type": null,
+              "old_line": 62,
+              "new_line": 62,
+              "text": "        (new this).initialize(node, options);"
+            },
+            {
+              "type": null,
+              "old_line": 63,
+              "new_line": 63,
+              "text": "      }.bind(this));"
+            },
+            {
+              "type": null,
+              "old_line": 64,
+              "new_line": 64,
+              "text": "    }"
+            },
+            {
+              "type": null,
+              "old_line": 65,
+              "new_line": 65,
+              "text": ""
+            }
+          ]
+        },
+        {
+          "conflict": true,
+          "id": "section124",
+          "lines": [
+            {
+              "type": "old",
+              "old_line": 67,
+              "new_line": null,
+              "text": "    function removeFrom(selector) {"
+            },
+            {
+              "type": "old",
+              "old_line": 68,
+              "new_line": null,
+              "text": "      if (!selector) {"
+            },
+            {
+              "type": "old",
+              "old_line": 69,
+              "new_line": null,
+              "text": "        throw new Error(\"Component needs to be removeFrom'd a jQuery object, native node or selector string\");"
+            },
+            {
+              "type": "old",
+              "old_line": 70,
+              "new_line": null,
+              "text": "      }"
+            },
+            {
+              "type": "old",
+              "old_line": 71,
+              "new_line": null,
+              "text": " "
+            },
+            {
+              "type": "old",
+              "old_line": 72,
+              "new_line": null,
+              "text": "      $(selector).each(function(i, rawNode) {"
+            },
+            {
+              "type": "old",
+              "old_line": 73,
+              "new_line": null,
+              "text": "        var componentInfo = registry.findComponentInfo(this)"
+            },
+            {
+              "type": "old",
+              "old_line": 74,
+              "new_line": null,
+              "text": "        if (componentInfo && componentInfo.isAttachedTo(rawNode)) {"
+            },
+            {
+              "type": "old",
+              "old_line": 75,
+              "new_line": null,
+              "text": "          Object.keys(componentInfo.instances).forEach(function(index) {"
+            },
+            {
+              "type": "old",
+              "old_line": 76,
+              "new_line": null,
+              "text": "            var instance = componentInfo.instances[index].instance;"
+            },
+            {
+              "type": "old",
+              "old_line": 77,
+              "new_line": null,
+              "text": "            if (instance.node === rawNode) {"
+            },
+            {
+              "type": "old",
+              "old_line": 78,
+              "new_line": null,
+              "text": "              instance.teardown();"
+            },
+            {
+              "type": "old",
+              "old_line": 79,
+              "new_line": null,
+              "text": "            }"
+            },
+            {
+              "type": "old",
+              "old_line": 80,
+              "new_line": null,
+              "text": "          });"
+            },
+            {
+              "type": "old",
+              "old_line": 81,
+              "new_line": null,
+              "text": "        }"
+            },
+            {
+              "type": "old",
+              "old_line": 82,
+              "new_line": null,
+              "text": "      }.bind(this));"
+            },
+            {
+              "type": "old",
+              "old_line": 83,
+              "new_line": null,
+              "text": "    }"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 67,
+              "text": "    function prettyPrintMixins() {"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 68,
+              "text": "      //could be called from constructor or constructor.prototype"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 69,
+              "text": "      var mixedIn = this.mixedIn || this.prototype.mixedIn || [];"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 70,
+              "text": "      return mixedIn.map(function(mixin) {"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 71,
+              "text": "        if (mixin.name == null) {"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 72,
+              "text": "          // function name property not supported by this browser, use regex"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 73,
+              "text": "          var m = mixin.toString().match(functionNameRegEx);"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 74,
+              "text": "          return (m && m[1]) ? m[1] : '';"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 75,
+              "text": "        } else {"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 76,
+              "text": "          return (mixin.name != 'withBase') ? mixin.name : '';"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 77,
+              "text": "        }"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 78,
+              "text": "      }).filter(Boolean).join(', ');"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 79,
+              "text": "    };"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 80,
+              "text": ""
+            }
+          ]
+        },
+        {
+          "conflict": false,
+          "lines": [
+            {
+              "type": null,
+              "old_line": 84,
+              "new_line": 81,
+              "text": ""
+            },
+            {
+              "type": null,
+              "old_line": 85,
+              "new_line": 82,
+              "text": "    // define the constructor for a custom component type"
+            },
+            {
+              "type": null,
+              "old_line": 86,
+              "new_line": 83,
+              "text": "    // takes an unlimited number of mixin functions as arguments"
+            },
+            {
+              "type": null,
+              "old_line": 87,
+              "new_line": 84,
+              "text": "    // typical api call with 3 mixins: define(timeline, withTweetCapability, withScrollCapability);"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "commit_sha": "c68b43c7c22b5b96e0e7b3b5fa56eb3f2cea5e21",
+      "old_path": "lib/registry.js",
+      "new_path": "lib/registry.js",
+      "sections": [
+        {
+          "conflict": false,
+          "lines": [
+            {
+              "type": null,
+              "old_line": 159,
+              "new_line": 159,
+              "text": ""
+            },
+            {
+              "type": null,
+              "old_line": 160,
+              "new_line": 160,
+              "text": "var thisInstanceInfo = this.allInstances[k]"
+            }
+          ]
+        },
+        {
+          "conflict": true,
+          "id": "section125",
+          "lines": [
+            {
+              "type": "old",
+              "old_line": 161,
+              "new_line": null,
+              "text": "if(thisInstanceInfo.instance.node == node){"
+            },
+            {
+              "type": "new",
+              "old_line": null,
+              "new_line": 161,
+              "text": "if (thisInstanceInfo.instance.node === node) {"
+            }
+          ]
+        },
+        {
+          "conflict": false,
+          "lines": [
+            {
+              "type": null,
+              "old_line": 162,
+              "new_line": 162,
+              "text": "result.push(thisInstanceInfo);"
+            }
+          ]
+        }
+      ]
     }
   ]
 }

From 6041fbce51f7895c1b92b131bcac7005804fdcbb Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Wed, 13 Jul 2016 03:07:48 +0300
Subject: [PATCH 09/90] Implemented conflict side selection.

---
 .../merge_conflict_resolver.js.coffee         | 54 ++++++++++++++-----
 .../merge_requests/show/_conflicts.html.haml  | 32 ++++++++---
 2 files changed, 65 insertions(+), 21 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.coffee b/app/assets/javascripts/merge_conflict_resolver.js.coffee
index 6a79212b04a..f251089a212 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.coffee
+++ b/app/assets/javascripts/merge_conflict_resolver.js.coffee
@@ -4,10 +4,14 @@ class window.MergeConflictResolver extends Vue
 
   constructor: (options = {}) ->
 
-    options.el      = '#conflicts'
-    options.data    = @getInitialData()
-    options.created = -> @fetchData()
-    options.name    = 'MergeConflictResolver'
+    options.el       = '#conflicts'
+    options.data     = @getInitialData()
+    options.name     = 'MergeConflictResolver'
+    options.created  = -> @fetchData()
+    options.computed =
+      conflictsCount : -> @getConflictsCount()
+      resolvedCount  : -> @getResolvedCount()
+      allResolved    : -> @isAllResolved()
 
     super options
 
@@ -43,7 +47,7 @@ class window.MergeConflictResolver extends Vue
 
   handleSelected: (sectionId, selection) ->
 
-    console.log sectionId, selection
+    @resolutionData[sectionId] = selection
 
 
   decorateData: (data) ->
@@ -51,6 +55,8 @@ class window.MergeConflictResolver extends Vue
     headHeaderText   = 'HEAD//our changes'
     originHeaderText = 'origin//their changes'
 
+    @updateResolutionsData data
+
     for file in data.files
       file.parallelLines  = { left: [], right: [] }
       file.inlineLines    = []
@@ -61,10 +67,10 @@ class window.MergeConflictResolver extends Vue
         { conflict, lines, id } = section
 
         if conflict
-          file.parallelLines.left.push  { isHeader: yes, id, text: headHeaderText, cssClass: 'head' }
-          file.parallelLines.right.push { isHeader: yes, id, text: originHeaderText, cssClass: 'origin' }
+          file.parallelLines.left.push  { isHeader: yes, id, text: headHeaderText, cssClass: 'head', section: 'head' }
+          file.parallelLines.right.push { isHeader: yes, id, text: originHeaderText, cssClass: 'origin', section: 'origin' }
 
-          file.inlineLines.push { isHeader: yes, id, text: headHeaderText, type: 'old', cssClass: 'head' }
+          file.inlineLines.push { isHeader: yes, id, text: headHeaderText, type: 'old', cssClass: 'head', section: 'head' }
 
         for line in lines
           if line.type in ['new', 'old'] and currentLineType isnt line.type
@@ -90,18 +96,40 @@ class window.MergeConflictResolver extends Vue
             file.parallelLines.right.push { lineType: 'context', lineNumber: line.new_line, text: line.text }
 
         if conflict
-          file.inlineLines.push { isHeader: yes, id, type: 'new', text: originHeaderText, cssClass: 'origin' }
+          file.inlineLines.push { isHeader: yes, id, type: 'new', text: originHeaderText, cssClass: 'origin', section: 'origin' }
 
     return data
 
 
+  getConflictsCount: -> return Object.keys(@resolutionData).length
+
+
+  getResolvedCount: ->
+
+    count = 0
+    count++ for id, resolution of @resolutionData when resolution
+
+    return count
+
+
+  isAllResolved: -> return @resolvedCount is @conflictsCount
+
+
+  updateResolutionsData: (data) ->
+
+    for file in data.files
+      for section in file.sections when section.conflict
+        @$set "resolutionData.#{section.id}", no
+
+
   getInitialData: ->
 
     diffViewType = $.cookie 'diff_view'
 
     return {
-      isLoading     : yes
-      diffView      : diffViewType
-      conflictsData : {}
-      isParallel    : diffViewType is 'parallel'
+      isLoading      : yes
+      isParallel     : diffViewType is 'parallel'
+      diffView       : diffViewType
+      conflictsData  : {}
+      resolutionData : {}
     }
diff --git a/app/views/projects/merge_requests/show/_conflicts.html.haml b/app/views/projects/merge_requests/show/_conflicts.html.haml
index fe415c1cfed..dc5d91778aa 100644
--- a/app/views/projects/merge_requests/show/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/show/_conflicts.html.haml
@@ -22,9 +22,8 @@
       into
       %strong {{conflictsData.target_branch}}
 
-
 .files-wrapper{ "v-if" => "!isLoading" }
-  .files{{"v-if" => "isParallel"}}
+  .files{"v-if" => "isParallel"}
     .diff-file.file-holder.conflict.unresolved.parallel-view{"v-for" => "file in conflictsData.files"}
       .file-title
         %i.fa.fa-ban
@@ -42,16 +41,16 @@
                 %td.diff-line-num.header
                 %td.line_content.header
                   %strong {{line.text}}
-                  %button.btn{"@click" => "handleSelected(line.id, line.lineType)"} Use this
+                  / FIXME: Don't use cssClass here
+                  %button.btn{"@click" => "handleSelected(line.id, line.cssClass)"} Use this
 
               %template{"v-if" => "!line.isHeader"}
                 %td.diff-line-num.old_line
                   {{line.lineNumber}}
                 %td.line_content
-                  {{line.text}}
+                  {{{line.text}}}
 
-
-  .files{{"v-if" => "!isParallel"}}
+  .files{"v-if" => "!isParallel"}
     .diff-file.file-holder.conflict.unresolved.inline-view{"v-for" => "file in conflictsData.files"}
       .file-title
         %i.fa.fa-ban
@@ -77,5 +76,22 @@
                 %td.diff-line-num.header
                 %td.diff-line-num.header
                 %td.line_content.header
-                  %strong {{line.text}}
-                  %button.btn{"@click" => "handleSelected(line.id, line.type)"} Use this
+                  %strong {{{line.text}}}
+                  / FIXME: Don't use cssClass here
+                  %button.btn{"@click" => "handleSelected(line.id, line.cssClass)"} Use this
+
+  .content-block.oneline-block.files-changed
+    %strong.resolved-count {{resolvedCount}}
+    of
+    %strong.total-count {{conflictsCount}}
+    conflicts have been resolved
+
+    .commit-message-container.form-group
+      .max-width-marker
+      %textarea.form-control.js-commit-message{"placeholder" => 'Your commit message', ":disabled" => "!allResolved"}
+
+    %button{type: 'button', class: 'btn btn-success js-submit-button', ":disabled" => "!allResolved"}
+      Commit conflict resolution
+
+    %button{type: 'button', class: 'btn btn-cancel'}
+      Cancel

From be50552922a4dfe57adcc0c8dec9548ed69a7848 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Wed, 13 Jul 2016 14:43:00 +0300
Subject: [PATCH 10/90] Remove icon and get conflicts count from data.

---
 .../merge_requests/show/_conflicts.html.haml       | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/app/views/projects/merge_requests/show/_conflicts.html.haml b/app/views/projects/merge_requests/show/_conflicts.html.haml
index dc5d91778aa..447a7f0e66b 100644
--- a/app/views/projects/merge_requests/show/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/show/_conflicts.html.haml
@@ -16,7 +16,7 @@
   .js-toggle-container
     .commit-stat-summary
       Showing
-      %strong.cred 3 conflicts
+      %strong.cred {{conflictsCount}} conflicts
       for
       %strong {{conflictsData.source_branch}}
       into
@@ -24,11 +24,9 @@
 
 .files-wrapper{ "v-if" => "!isLoading" }
   .files{"v-if" => "isParallel"}
-    .diff-file.file-holder.conflict.unresolved.parallel-view{"v-for" => "file in conflictsData.files"}
+    .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
       .file-title
-        %i.fa.fa-ban
-        %a
-          %span {{file.new_path}}
+        %span {{file.new_path}}
         .file-actions
           %a.btn.btn-sm View file @{{file.shortCommitSha}}
 
@@ -51,11 +49,9 @@
                   {{{line.text}}}
 
   .files{"v-if" => "!isParallel"}
-    .diff-file.file-holder.conflict.unresolved.inline-view{"v-for" => "file in conflictsData.files"}
+    .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}
       .file-title
-        %i.fa.fa-ban
-        %a
-          %span {{file.new_path}}
+        %span {{file.new_path}}
         .file-actions
           %a.btn.btn-sm View file @{{file.shortCommitSha}}
 

From f3743111a7c5470171a2ca224e28b838c5bd17e7 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Wed, 13 Jul 2016 14:43:13 +0300
Subject: [PATCH 11/90] Styling for selected/unselected versions.

---
 .../stylesheets/pages/merge_conflicts.scss    | 44 ++++++++++++++++---
 1 file changed, 38 insertions(+), 6 deletions(-)

diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index 6e77fc1c2e3..e40c4f045a2 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -1,10 +1,15 @@
 $head_line:               #EFFDEB;
-$head_header:             #DAFACE;
-$head_header_selected:    #BAF0A8;
+$head_gutter:             #DAFACE;
+$selected_head_gutter:    #B2EE9E;
+$selected_head_line:      #D4F5C9;
 
 $origin_line:             #F2F9FF;
-$origin_header:           #E0F0FF;
-$origin_header_selected:  #ADD8FF;
+$origin_gutter:           #E0F0FF;
+$selected_origin_gutter:  #A3D3FF;
+$selected_origin_line:    #CEE4F9;
+
+$unselected_gutter:       #EEEEEE;
+$unselected_line:         #F8F8F8;
 
 
 #conflicts {
@@ -15,20 +20,47 @@ $origin_header_selected:  #ADD8FF;
 
   .head {
     .header, .diff-line-num {
-      background-color: $head_header;
+      background-color: $head_gutter;
     }
     td {
       background-color: $head_line;
     }
+    &.selected {
+      .header, .diff-line-num {
+        background-color: $selected_head_gutter;
+      }
+      td {
+        background-color: $selected_head_line;
+      }
+    }
   }
 
   .origin {
     .header, .diff-line-num {
-      background-color: $origin_header;
+      background-color: $origin_gutter;
     }
     td {
       background-color: $origin_line;
     }
+    &.selected {
+      .header, .diff-line-num {
+        background-color: $selected_origin_gutter;
+      }
+      td {
+        background-color: $selected_origin_line;
+      }
+    }
+  }
+
+  .origin, .head {
+    &.unselected {
+      .header, .diff-line-num {
+        background-color: $unselected_gutter;
+      }
+      td {
+        background-color: $unselected_line;
+      }
+    }
   }
 
   .parallel-view {

From ff15fbf10c8c32fde876e5c9578fdc2161b7905c Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Thu, 14 Jul 2016 00:57:31 +0300
Subject: [PATCH 12/90] Implement conflict selection with highlighting.

---
 .../merge_conflict_resolver.js.coffee         | 48 ++++++++++++++++---
 .../stylesheets/pages/merge_conflicts.scss    |  8 ++++
 .../merge_requests/show/_conflicts.html.haml  | 20 +++++---
 3 files changed, 63 insertions(+), 13 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.coffee b/app/assets/javascripts/merge_conflict_resolver.js.coffee
index f251089a212..04fbb8666bf 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.coffee
+++ b/app/assets/javascripts/merge_conflict_resolver.js.coffee
@@ -49,6 +49,33 @@ class window.MergeConflictResolver extends Vue
 
     @resolutionData[sectionId] = selection
 
+    #FIXME: Dry!!
+    for file in @conflictsData.files
+      for line in file.inlineLines
+        if line.id is sectionId and (line.conflict or line.isHeader)
+          if selection is 'head' and line.isHead
+            line.isSelected = yes
+            line.isUnselected = no
+          else if selection is 'origin' and line.isOrigin
+            line.isSelected = yes
+            line.isUnselected = no
+          else
+            line.isUnselected = yes
+            line.isSelected = no
+
+      for section, lines of file.parallelLines
+        for line in lines
+          if line.id is sectionId and (line.lineType is 'conflict' or line.isHeader)
+            if selection is 'head' and line.isHead
+              line.isSelected = yes
+              line.isUnselected = no
+            else if selection is 'origin' and line.isOrigin
+              line.isSelected = yes
+              line.isUnselected = no
+            else
+              line.isUnselected = yes
+              line.isSelected = no
+
 
   decorateData: (data) ->
 
@@ -57,6 +84,7 @@ class window.MergeConflictResolver extends Vue
 
     @updateResolutionsData data
 
+    # FIXME: Add comments and separate parallel and inline data decoration
     for file in data.files
       file.parallelLines  = { left: [], right: [] }
       file.inlineLines    = []
@@ -67,10 +95,11 @@ class window.MergeConflictResolver extends Vue
         { conflict, lines, id } = section
 
         if conflict
-          file.parallelLines.left.push  { isHeader: yes, id, text: headHeaderText, cssClass: 'head', section: 'head' }
-          file.parallelLines.right.push { isHeader: yes, id, text: originHeaderText, cssClass: 'origin', section: 'origin' }
+          # FIXME: Make these lines better
+          file.parallelLines.left.push  { isHeader: yes, id, text: headHeaderText, section: 'head', isHead: yes, isSelected: no, isUnselected: no }
+          file.parallelLines.right.push { isHeader: yes, id, text: originHeaderText, section: 'origin', isOrigin: yes, isSelected: no, isUnselected: no }
 
-          file.inlineLines.push { isHeader: yes, id, text: headHeaderText, type: 'old', cssClass: 'head', section: 'head' }
+          file.inlineLines.push { isHeader: yes, id, text: headHeaderText, type: 'old', section: 'head', isHead: yes, isSelected: no, isUnselected: no }
 
         for line in lines
           if line.type in ['new', 'old'] and currentLineType isnt line.type
@@ -78,16 +107,21 @@ class window.MergeConflictResolver extends Vue
             # FIXME: Find a better way to add a new line
             file.inlineLines.push { lineType: 'emptyLine', text: '<span> </span>' }
 
+          # FIXME: Make these lines better
           line.conflict = conflict
-          line.cssClass = if line.type is 'old' then 'head' else if line.type is 'new' then 'origin' else ''
+          line.id = id
+          line.isHead = line.type is 'old'
+          line.isOrigin = line.type is 'new'
+          line.isSelected = no
+          line.isUnselected = no
           file.inlineLines.push line
 
           if conflict
             if line.type is 'old'
-              line = { lineType: 'conflict', lineNumber: line.old_line, text: line.text, cssClass: 'head' }
+              line = { lineType: 'conflict', lineNumber: line.old_line, text: line.text, section: 'head', id, isSelected: no, isUnselected: no, isHead: yes }
               file.parallelLines.left.push  line
             else if line.type is 'new'
-              line = { lineType: 'conflict', lineNumber: line.new_line, text: line.text, cssClass: 'origin' }
+              line = { lineType: 'conflict', lineNumber: line.new_line, text: line.text, section: 'origin', id, isSelected: no, isUnselected: no, isOrigin: yes }
               file.parallelLines.right.push line
             else
               console.log 'unhandled line type...', line
@@ -96,7 +130,7 @@ class window.MergeConflictResolver extends Vue
             file.parallelLines.right.push { lineType: 'context', lineNumber: line.new_line, text: line.text }
 
         if conflict
-          file.inlineLines.push { isHeader: yes, id, type: 'new', text: originHeaderText, cssClass: 'origin', section: 'origin' }
+          file.inlineLines.push { isHeader: yes, id, type: 'new', text: originHeaderText, section: 'origin', isOrigin: yes, isSelected: no, isUnselected: no }
 
     return data
 
diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index e40c4f045a2..f55134f968c 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -22,13 +22,16 @@ $unselected_line:         #F8F8F8;
     .header, .diff-line-num {
       background-color: $head_gutter;
     }
+
     td {
       background-color: $head_line;
     }
+
     &.selected {
       .header, .diff-line-num {
         background-color: $selected_head_gutter;
       }
+
       td {
         background-color: $selected_head_line;
       }
@@ -39,13 +42,16 @@ $unselected_line:         #F8F8F8;
     .header, .diff-line-num {
       background-color: $origin_gutter;
     }
+
     td {
       background-color: $origin_line;
     }
+
     &.selected {
       .header, .diff-line-num {
         background-color: $selected_origin_gutter;
       }
+
       td {
         background-color: $selected_origin_line;
       }
@@ -57,6 +63,7 @@ $unselected_line:         #F8F8F8;
       .header, .diff-line-num {
         background-color: $unselected_gutter;
       }
+
       td {
         background-color: $unselected_line;
       }
@@ -66,6 +73,7 @@ $unselected_line:         #F8F8F8;
   .parallel-view {
     .diff-content {
       overflow: hidden;
+
       table {
         width: 50%;
         float: left;
diff --git a/app/views/projects/merge_requests/show/_conflicts.html.haml b/app/views/projects/merge_requests/show/_conflicts.html.haml
index 447a7f0e66b..9aa4e17a649 100644
--- a/app/views/projects/merge_requests/show/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/show/_conflicts.html.haml
@@ -33,14 +33,18 @@
       .diff-content.diff-wrap-lines
         .diff-wrap-lines.code.file-content.js-syntax-highlight.white
           %table{"v-for" => "(key, group) in file.parallelLines"}
-            %tr.line_holder.parallel{"v-for" => "line in group", ":class" => "line.cssClass"}
+            %tr.line_holder.parallel{"v-for" => "line in group", |
+              ":class" => "{ |
+                'head': line.isHead, |
+                'origin': line.isOrigin, |
+                'selected': line.isSelected, |
+                'unselected': line.isUnselected }"}
 
               %template{"v-if" => "line.isHeader"}
                 %td.diff-line-num.header
                 %td.line_content.header
                   %strong {{line.text}}
-                  / FIXME: Don't use cssClass here
-                  %button.btn{"@click" => "handleSelected(line.id, line.cssClass)"} Use this
+                  %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
 
               %template{"v-if" => "!line.isHeader"}
                 %td.diff-line-num.old_line
@@ -58,7 +62,12 @@
       .diff-content.diff-wrap-lines
         .diff-wrap-lines.code.file-content.js-syntax-highlight.white
           %table
-            %tr.line_holder{"v-for" => "line in file.inlineLines", ":class" => "line.cssClass"}
+            %tr.line_holder{"v-for" => "line in file.inlineLines", |
+              ":class" => "{ |
+                'head': line.isHead, |
+                'origin': line.isOrigin, |
+                'selected': line.isSelected, |
+                'unselected': line.isUnselected }"}
 
               %template{"v-if" => "!line.isHeader"}
                 %td.diff-line-num.old_line
@@ -73,8 +82,7 @@
                 %td.diff-line-num.header
                 %td.line_content.header
                   %strong {{{line.text}}}
-                  / FIXME: Don't use cssClass here
-                  %button.btn{"@click" => "handleSelected(line.id, line.cssClass)"} Use this
+                  %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
 
   .content-block.oneline-block.files-changed
     %strong.resolved-count {{resolvedCount}}

From df2ed097b730c8ba0b79cac8cc3dbfcb0cf587cb Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Mon, 25 Jul 2016 19:47:09 +0100
Subject: [PATCH 13/90] Add backend for merge conflicts reading

---
 .../merge_conflict_resolver.js.coffee         |  30 +--
 .../javascripts/merge_conflicts_data.coffee   |   2 +-
 .../projects/merge_requests_controller.rb     |  32 +++-
 .../merge_requests/show/_conflicts.html.haml  |  10 +-
 lib/gitlab/conflict/file.rb                   |  91 +++++++++
 lib/gitlab/conflict/parser.rb                 |  59 ++++++
 lib/gitlab/diff/line.rb                       |  11 ++
 spec/lib/gitlab/conflict/file_spec.rb         |  76 ++++++++
 spec/lib/gitlab/conflict/parser_spec.rb       | 178 ++++++++++++++++++
 spec/support/test_env.rb                      |   2 +
 10 files changed, 469 insertions(+), 22 deletions(-)
 create mode 100644 lib/gitlab/conflict/file.rb
 create mode 100644 lib/gitlab/conflict/parser.rb
 create mode 100644 spec/lib/gitlab/conflict/file_spec.rb
 create mode 100644 spec/lib/gitlab/conflict/parser_spec.rb

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.coffee b/app/assets/javascripts/merge_conflict_resolver.js.coffee
index 04fbb8666bf..47ff8b7825b 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.coffee
+++ b/app/assets/javascripts/merge_conflict_resolver.js.coffee
@@ -21,9 +21,9 @@ class window.MergeConflictResolver extends Vue
   fetchData: ->
 
     $.ajax
-      url    : '/emojis'
+      url    : './conflicts.json'
       success: (response) =>
-        @handleResponse window.mergeConflictsData
+        @handleResponse response
 
 
   handleResponse: (data) ->
@@ -81,6 +81,8 @@ class window.MergeConflictResolver extends Vue
 
     headHeaderText   = 'HEAD//our changes'
     originHeaderText = 'origin//their changes'
+    data.shortCommitSha = data.commit_sha.slice 0, 7
+    data.commitMessage = data.commit_message
 
     @updateResolutionsData data
 
@@ -88,7 +90,6 @@ class window.MergeConflictResolver extends Vue
     for file in data.files
       file.parallelLines  = { left: [], right: [] }
       file.inlineLines    = []
-      file.shortCommitSha = file.commit_sha.slice 0, 7
       currentLineType     = 'old'
 
       for section in file.sections
@@ -96,41 +97,42 @@ class window.MergeConflictResolver extends Vue
 
         if conflict
           # FIXME: Make these lines better
-          file.parallelLines.left.push  { isHeader: yes, id, text: headHeaderText, section: 'head', isHead: yes, isSelected: no, isUnselected: no }
-          file.parallelLines.right.push { isHeader: yes, id, text: originHeaderText, section: 'origin', isOrigin: yes, isSelected: no, isUnselected: no }
+          file.parallelLines.left.push  { isHeader: yes, id, richText: headHeaderText, section: 'head', isHead: yes, isSelected: no, isUnselected: no }
+          file.parallelLines.right.push { isHeader: yes, id, richText: originHeaderText, section: 'origin', isOrigin: yes, isSelected: no, isUnselected: no }
 
-          file.inlineLines.push { isHeader: yes, id, text: headHeaderText, type: 'old', section: 'head', isHead: yes, isSelected: no, isUnselected: no }
+          file.inlineLines.push { isHeader: yes, id, richText: headHeaderText, type: 'old', section: 'head', isHead: yes, isSelected: no, isUnselected: no }
 
         for line in lines
           if line.type in ['new', 'old'] and currentLineType isnt line.type
             currentLineType = line.type
             # FIXME: Find a better way to add a new line
-            file.inlineLines.push { lineType: 'emptyLine', text: '<span> </span>' }
+            file.inlineLines.push { lineType: 'emptyLine', richText: '<span> </span>' }
 
           # FIXME: Make these lines better
           line.conflict = conflict
           line.id = id
-          line.isHead = line.type is 'old'
-          line.isOrigin = line.type is 'new'
+          line.isHead = line.type is 'new'
+          line.isOrigin = line.type is 'old'
           line.isSelected = no
           line.isUnselected = no
+          line.richText = line.rich_text
           file.inlineLines.push line
 
           if conflict
             if line.type is 'old'
-              line = { lineType: 'conflict', lineNumber: line.old_line, text: line.text, section: 'head', id, isSelected: no, isUnselected: no, isHead: yes }
+              line = { lineType: 'conflict', lineNumber: line.old_line, richText: line.rich_text, section: 'origin', id, isSelected: no, isUnselected: no, isOrigin: yes }
               file.parallelLines.left.push  line
             else if line.type is 'new'
-              line = { lineType: 'conflict', lineNumber: line.new_line, text: line.text, section: 'origin', id, isSelected: no, isUnselected: no, isOrigin: yes }
+              line = { lineType: 'conflict', lineNumber: line.new_line, richText: line.rich_text, section: 'head', id, isSelected: no, isUnselected: no, isHead: yes }
               file.parallelLines.right.push line
             else
               console.log 'unhandled line type...', line
           else
-            file.parallelLines.left.push  { lineType: 'context', lineNumber: line.old_line, text: line.text }
-            file.parallelLines.right.push { lineType: 'context', lineNumber: line.new_line, text: line.text }
+            file.parallelLines.left.push  { lineType: 'context', lineNumber: line.old_line, richText: line.rich_text }
+            file.parallelLines.right.push { lineType: 'context', lineNumber: line.new_line, richText: line.rich_text }
 
         if conflict
-          file.inlineLines.push { isHeader: yes, id, type: 'new', text: originHeaderText, section: 'origin', isOrigin: yes, isSelected: no, isUnselected: no }
+          file.inlineLines.push { isHeader: yes, id, type: 'new', richText: originHeaderText, section: 'origin', isOrigin: yes, isSelected: no, isUnselected: no }
 
     return data
 
diff --git a/app/assets/javascripts/merge_conflicts_data.coffee b/app/assets/javascripts/merge_conflicts_data.coffee
index a302424f421..7d89a87cf14 100644
--- a/app/assets/javascripts/merge_conflicts_data.coffee
+++ b/app/assets/javascripts/merge_conflicts_data.coffee
@@ -1,9 +1,9 @@
 window.mergeConflictsData = {
   "target_branch": "master",
   "source_branch": "mc-ui",
+  "commit_sha": "b5fa56eb3f2cea5e21c68b43c7c22b5b96e0e7b3",
   "files": [
     {
-      "commit_sha": "b5fa56eb3f2cea5e21c68b43c7c22b5b96e0e7b3",
       "old_path": "lib/component.js",
       "new_path": "lib/component.js",
       "sections": [
diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 4fa7d971013..689c9627762 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -17,7 +17,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
   before_action :define_widget_vars, only: [:merge, :cancel_merge_when_build_succeeds, :merge_check]
   before_action :define_commit_vars, only: [:diffs]
   before_action :define_diff_comment_vars, only: [:diffs]
-  before_action :ensure_ref_fetched, only: [:show, :diffs, :commits, :builds]
+  before_action :ensure_ref_fetched, only: [:show, :diffs, :commits, :builds, :conflicts]
 
   # Allow read any merge_request
   before_action :authorize_read_merge_request!
@@ -130,10 +130,38 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     end
   end
 
-
   def conflicts
+    return render_404 unless @merge_request.cannot_be_merged?
+
     respond_to do |format|
       format.html { render 'show' }
+      format.json do
+        rugged = @merge_request.project.repository.rugged
+        their_commit = rugged.branches[@merge_request.target_branch].target
+        our_commit = rugged.lookup(@merge_request.diff_head_sha)
+        merge = rugged.merge_commits(our_commit, their_commit)
+        commit_message = "Merge branch '#{@merge_request.target_branch}' into '#{@merge_request.source_branch}'\n\n# Conflicts:"
+
+        files = merge.conflicts.map do |conflict|
+          their_path = conflict[:theirs][:path]
+          our_path = conflict[:ours][:path]
+
+          raise 'path mismatch!' unless their_path == our_path
+
+          commit_message << "\n#   #{our_path}"
+          merge_file = merge.merge_file(our_path)
+
+          Gitlab::Conflict::File.new(merge_file, conflict, @merge_request.target_branch, @merge_request.source_branch, @merge_request.project.repository)
+        end
+
+        render json: {
+          target_branch: @merge_request.target_branch,
+          source_branch: @merge_request.source_branch,
+          commit_sha: @merge_request.diff_head_sha,
+          commit_message: commit_message,
+          files: files
+        }
+      end
     end
   end
 
diff --git a/app/views/projects/merge_requests/show/_conflicts.html.haml b/app/views/projects/merge_requests/show/_conflicts.html.haml
index 9aa4e17a649..d40f231cf53 100644
--- a/app/views/projects/merge_requests/show/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/show/_conflicts.html.haml
@@ -28,7 +28,7 @@
       .file-title
         %span {{file.new_path}}
         .file-actions
-          %a.btn.btn-sm View file @{{file.shortCommitSha}}
+          %a.btn.btn-sm View file @{{conflictsData.shortCommitShab}}
 
       .diff-content.diff-wrap-lines
         .diff-wrap-lines.code.file-content.js-syntax-highlight.white
@@ -57,7 +57,7 @@
       .file-title
         %span {{file.new_path}}
         .file-actions
-          %a.btn.btn-sm View file @{{file.shortCommitSha}}
+          %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
 
       .diff-content.diff-wrap-lines
         .diff-wrap-lines.code.file-content.js-syntax-highlight.white
@@ -75,13 +75,13 @@
                 %td.diff-line-num.new_line
                   %a {{line.new_line}}
                 %td.line_content
-                  {{{line.text}}}
+                  {{{line.rich_text}}}
 
               %template{"v-if" => "line.isHeader"}
                 %td.diff-line-num.header
                 %td.diff-line-num.header
                 %td.line_content.header
-                  %strong {{{line.text}}}
+                  %strong {{{line.richText}}}
                   %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
 
   .content-block.oneline-block.files-changed
@@ -92,7 +92,7 @@
 
     .commit-message-container.form-group
       .max-width-marker
-      %textarea.form-control.js-commit-message{"placeholder" => 'Your commit message', ":disabled" => "!allResolved"}
+      %textarea.form-control.js-commit-message{":disabled" => "!allResolved"} {{{conflictsData.commitMessage}}}
 
     %button{type: 'button', class: 'btn btn-success js-submit-button', ":disabled" => "!allResolved"}
       Commit conflict resolution
diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
new file mode 100644
index 00000000000..84d3e6f4e03
--- /dev/null
+++ b/lib/gitlab/conflict/file.rb
@@ -0,0 +1,91 @@
+module Gitlab
+  module Conflict
+    class File
+      CONTEXT_LINES = 3
+
+      attr_reader :merge_file, :their_path, :their_ref, :our_path, :our_ref, :repository
+
+      def initialize(merge_file, conflict, their_ref, our_ref, repository)
+        @merge_file = merge_file
+        @their_path = conflict[:theirs][:path]
+        @our_path = conflict[:ours][:path]
+        @their_ref = their_ref
+        @our_ref = our_ref
+        @repository = repository
+      end
+
+      # Array of Gitlab::Diff::Line objects
+      def lines
+        @lines ||= Gitlab::Conflict::Parser.new.parse(merge_file[:data], their_path, our_path)
+      end
+
+      def highlighted_lines
+        return @highlighted_lines if @highlighted_lines
+
+        their_highlight = Gitlab::Highlight.highlight_lines(repository, their_ref, their_path)
+        our_highlight = Gitlab::Highlight.highlight_lines(repository, our_ref, our_path)
+
+        @highlighted_lines = lines.map do |line|
+          line = line.dup
+          if line.type == 'old'
+            line.rich_text = their_highlight[line.old_line - 1].delete("\n")
+          else
+            line.rich_text = our_highlight[line.new_line - 1].delete("\n")
+          end
+          line
+        end
+      end
+
+      def sections
+        return @sections if @sections
+
+        chunked_lines = highlighted_lines.chunk { |line| line.type.nil? }
+        match_line = nil
+
+        @sections = chunked_lines.flat_map.with_index do |(no_conflict, lines), i|
+          section = nil
+
+          if no_conflict
+            conflict_before = i > 0
+            conflict_after = chunked_lines.peek
+
+            if conflict_before && conflict_after
+              if lines.length > CONTEXT_LINES * 2
+                tail_lines = lines.last(CONTEXT_LINES)
+                first_tail_line = tail_lines.first
+                match_line = Gitlab::Diff::Line.new('',
+                                                    'match',
+                                                    first_tail_line.index,
+                                                    first_tail_line.old_pos,
+                                                    first_tail_line.new_pos)
+
+                section = [
+                  { conflict: false, lines: lines.first(CONTEXT_LINES) },
+                  { conflict: false, lines: tail_lines.unshift(match_line) }
+                ]
+              end
+            elsif conflict_after
+              lines = lines.last(CONTEXT_LINES)
+            elsif conflict_before
+              lines = lines.first(CONTEXT_LINES)
+            end
+          end
+
+          if match_line && !section
+            match_line.text = "@@ -#{match_line.old_pos},#{lines.last.old_pos} +#{match_line.new_pos},#{lines.last.new_pos} @@"
+          end
+
+          section || { conflict: !no_conflict, lines: lines }
+        end
+      end
+
+      def as_json(opts = nil)
+        {
+          old_path: their_path,
+          new_path: our_path,
+          sections: sections
+        }
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/conflict/parser.rb b/lib/gitlab/conflict/parser.rb
new file mode 100644
index 00000000000..a233c268070
--- /dev/null
+++ b/lib/gitlab/conflict/parser.rb
@@ -0,0 +1,59 @@
+module Gitlab
+  module Conflict
+    class Parser
+      class UnexpectedDelimiter < StandardError
+      end
+
+      class MissingEndDelimiter < StandardError
+      end
+
+      def parse(text, their_path, our_path)
+        return [] if text.blank?
+
+        line_obj_index = 0
+        line_old = 1
+        line_new = 1
+        type = nil
+        lines = []
+        conflict_start = "<<<<<<< #{our_path}"
+        conflict_middle = '======='
+        conflict_end = ">>>>>>> #{their_path}"
+
+        text.each_line.map do |line|
+          full_line = line.delete("\n")
+
+          if full_line == conflict_start
+            raise UnexpectedDelimiter unless type.nil?
+
+            type = 'new'
+          elsif full_line == conflict_middle
+            raise UnexpectedDelimiter unless type == 'new'
+
+            type = 'old'
+          elsif full_line == conflict_end
+            raise UnexpectedDelimiter unless type == 'old'
+
+            type = nil
+          elsif line[0] == '\\'
+            type = 'nonewline'
+            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new)
+          else
+            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new)
+            line_old += 1 if type != 'new'
+            line_new += 1 if type != 'old'
+
+            line_obj_index += 1
+          end
+        end
+
+        raise MissingEndDelimiter unless type == nil
+
+        lines
+      end
+
+      def empty?
+        @lines.empty?
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/diff/line.rb b/lib/gitlab/diff/line.rb
index cf097e0d0de..5196051f90d 100644
--- a/lib/gitlab/diff/line.rb
+++ b/lib/gitlab/diff/line.rb
@@ -3,6 +3,7 @@ module Gitlab
     class Line
       attr_reader :type, :index, :old_pos, :new_pos
       attr_accessor :text
+      attr_accessor :rich_text
 
       def initialize(text, type, index, old_pos, new_pos)
         @text, @type, @index = text, type, index
@@ -46,6 +47,16 @@ module Gitlab
       def meta?
         type == 'match' || type == 'nonewline'
       end
+
+      def as_json(opts = nil)
+        {
+          type: type,
+          old_line: old_line,
+          new_line: new_line,
+          text: text,
+          rich_text: rich_text || text
+        }
+      end
     end
   end
 end
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
new file mode 100644
index 00000000000..318d0d249d6
--- /dev/null
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Gitlab::Conflict::File, lib: true do
+  let(:project) { create(:project) }
+  let(:repository) { project.repository }
+  let(:rugged) { repository.rugged }
+  let(:their_ref) { their_commit.oid }
+  let(:their_commit) { rugged.branches['conflict-a'].target }
+  let(:our_ref) { our_commit.oid }
+  let(:our_commit) { rugged.branches['conflict-b'].target }
+  let(:index) { rugged.merge_commits(our_commit, their_commit) }
+  let(:conflict) { index.conflicts.last }
+  let(:merge_file) { index.merge_file('files/ruby/regex.rb') }
+  let(:conflict_file) { Gitlab::Conflict::File.new(merge_file, conflict, their_ref, our_ref, repository) }
+
+  describe '#highlighted_lines' do
+    def html_to_text(html)
+      CGI.unescapeHTML(ActionView::Base.full_sanitizer.sanitize(html))
+    end
+
+    it 'returns lines with rich_text' do
+      conflict_file.highlighted_lines.each do |line|
+        expect(line).to have_attributes(rich_text: an_instance_of(String))
+      end
+    end
+
+    it 'returns lines with rich_text matching the text content of the line' do
+      conflict_file.highlighted_lines.each do |line|
+        expect(line.text).to eq(html_to_text(line.rich_text))
+      end
+    end
+  end
+
+  describe '#sections' do
+    it 'returns match lines when there is a gap between sections' do
+      section = conflict_file.sections[5]
+      match_line = section[:lines][0]
+
+      expect(section[:conflict]).to be_falsey
+      expect(match_line.type).to eq('match')
+      expect(match_line.text).to eq('@@ -46,53 +46,53 @@')
+    end
+
+    it 'does not return match lines when there is no gap between sections' do
+      conflict_file.sections.each_with_index do |section, i|
+        unless i == 5
+          expect(section[:lines][0].type).not_to eq(5)
+        end
+      end
+    end
+
+    it 'sets conflict to false for sections with only unchanged lines' do
+      conflict_file.sections.reject { |section| section[:conflict] }.each do |section|
+        without_match = section[:lines].reject { |line| line.type == 'match' }
+
+        expect(without_match).to all(have_attributes(type: nil))
+      end
+    end
+
+    it 'only includes a maximum of CONTEXT_LINES (plus an optional match line) in context sections' do
+      conflict_file.sections.reject { |section| section[:conflict] }.each do |section|
+        without_match = section[:lines].reject { |line| line.type == 'match' }
+
+        expect(without_match.length).to be <= Gitlab::Conflict::File::CONTEXT_LINES * 2
+      end
+    end
+
+    it 'sets conflict to true for sections with only changed lines' do
+      conflict_file.sections.select { |section| section[:conflict] }.each do |section|
+        section[:lines].each do |line|
+          expect(line.type).to be_in(['new', 'old'])
+        end
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/conflict/parser_spec.rb b/spec/lib/gitlab/conflict/parser_spec.rb
new file mode 100644
index 00000000000..335da58e13c
--- /dev/null
+++ b/spec/lib/gitlab/conflict/parser_spec.rb
@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Gitlab::Conflict::Parser, lib: true do
+  let(:parser) { Gitlab::Conflict::Parser.new }
+
+  describe '#parse' do
+    context 'when the file has valid conflicts' do
+      let(:text) do
+        <<CONFLICT
+module Gitlab
+  module Regexp
+    extend self
+
+    def username_regexp
+      default_regexp
+    end
+
+<<<<<<< files/ruby/regex.rb
+    def project_name_regexp
+      /\A[a-zA-Z0-9][a-zA-Z0-9_\-\. ]*\z/
+    end
+
+    def name_regexp
+      /\A[a-zA-Z0-9_\-\. ]*\z/
+=======
+    def project_name_regex
+      %r{\A[a-zA-Z0-9][a-zA-Z0-9_\-\. ]*\z}
+    end
+
+    def name_regex
+      %r{\A[a-zA-Z0-9_\-\. ]*\z}
+>>>>>>> files/ruby/regex.rb
+    end
+
+    def path_regexp
+      default_regexp
+    end
+
+<<<<<<< files/ruby/regex.rb
+    def archive_formats_regexp
+      /(zip|tar|7z|tar\.gz|tgz|gz|tar\.bz2|tbz|tbz2|tb2|bz2)/
+=======
+    def archive_formats_regex
+      %r{(zip|tar|7z|tar\.gz|tgz|gz|tar\.bz2|tbz|tbz2|tb2|bz2)}
+>>>>>>> files/ruby/regex.rb
+    end
+
+    def git_reference_regexp
+      # Valid git ref regexp, see:
+      # https://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
+      %r{
+        (?!
+           (?# doesn't begins with)
+           \/|                    (?# rule #6)
+           (?# doesn't contain)
+           .*(?:
+              [\/.]\.|            (?# rule #1,3)
+              \/\/|               (?# rule #6)
+              @\{|                (?# rule #8)
+              \\                  (?# rule #9)
+           )
+        )
+        [^\000-\040\177~^:?*\[]+  (?# rule #4-5)
+        (?# doesn't end with)
+        (?<!\.lock)               (?# rule #1)
+        (?<![\/.])                (?# rule #6-7)
+      }x
+    end
+
+    protected
+
+<<<<<<< files/ruby/regex.rb
+    def default_regexp
+      /\A[.?]?[a-zA-Z0-9][a-zA-Z0-9_\-\.]*(?<!\.git)\z/
+=======
+    def default_regex
+      %r{\A[.?]?[a-zA-Z0-9][a-zA-Z0-9_\-\.]*(?<!\.git)\z}
+>>>>>>> files/ruby/regex.rb
+    end
+  end
+end
+CONFLICT
+      end
+
+      let(:lines) { parser.parse(text, 'files/ruby/regex.rb', 'files/ruby/regex.rb') }
+
+      it 'sets our lines as new lines' do
+        expect(lines[8..13]).to all(have_attributes(type: 'new'))
+        expect(lines[26..27]).to all(have_attributes(type: 'new'))
+        expect(lines[56..57]).to all(have_attributes(type: 'new'))
+      end
+
+      it 'sets their lines as old lines' do
+        expect(lines[14..19]).to all(have_attributes(type: 'old'))
+        expect(lines[28..29]).to all(have_attributes(type: 'old'))
+        expect(lines[58..59]).to all(have_attributes(type: 'old'))
+      end
+
+      it 'sets non-conflicted lines as both' do
+        expect(lines[0..7]).to all(have_attributes(type: nil))
+        expect(lines[20..25]).to all(have_attributes(type: nil))
+        expect(lines[30..55]).to all(have_attributes(type: nil))
+        expect(lines[60..62]).to all(have_attributes(type: nil))
+      end
+
+      it 'sets consecutive line numbers for index, old_pos, and new_pos' do
+        old_line_numbers = lines.select { |line| line.type != 'new' }.map(&:old_pos)
+        new_line_numbers = lines.select { |line| line.type != 'old' }.map(&:new_pos)
+
+        expect(lines.map(&:index)).to eq(0.upto(62).to_a)
+        expect(old_line_numbers).to eq(1.upto(53).to_a)
+        expect(new_line_numbers).to eq(1.upto(53).to_a)
+      end
+    end
+
+    context 'when the file contents include conflict delimiters' do
+      let(:path) { 'README.md' }
+
+      def parse_text(text)
+        parser.parse(text, path, path)
+      end
+
+      it 'raises UnexpectedDelimiter when there is a non-start delimiter first' do
+        expect { parse_text('=======') }.
+          to raise_error(Gitlab::Conflict::Parser::UnexpectedDelimiter)
+
+        expect { parse_text('>>>>>>> README.md') }.
+          to raise_error(Gitlab::Conflict::Parser::UnexpectedDelimiter)
+
+        expect { parse_text('>>>>>>> some-other-path.md') }.
+          not_to raise_error
+      end
+
+      it 'raises UnexpectedDelimiter when a start delimiter is followed by a non-middle delimiter' do
+        start_text = "<<<<<<< README.md\n"
+        end_text = "\n=======\n>>>>>>> README.md"
+
+        expect { parse_text(start_text + '>>>>>>> README.md' + end_text) }.
+          to raise_error(Gitlab::Conflict::Parser::UnexpectedDelimiter)
+
+        expect { parse_text(start_text + start_text + end_text) }.
+          to raise_error(Gitlab::Conflict::Parser::UnexpectedDelimiter)
+
+        expect { parse_text(start_text + '>>>>>>> some-other-path.md' + end_text) }.
+          not_to raise_error
+      end
+
+      it 'raises UnexpectedDelimiter when a middle delimiter is followed by a non-end delimiter' do
+        start_text = "<<<<<<< README.md\n=======\n"
+        end_text = "\n>>>>>>> README.md"
+
+        expect { parse_text(start_text + '=======' + end_text) }.
+          to raise_error(Gitlab::Conflict::Parser::UnexpectedDelimiter)
+
+        expect { parse_text(start_text + start_text + end_text) }.
+          to raise_error(Gitlab::Conflict::Parser::UnexpectedDelimiter)
+
+        expect { parse_text(start_text + '>>>>>>> some-other-path.md' + end_text) }.
+          not_to raise_error
+      end
+
+      it 'raises MissingEndDelimiter when there is no end delimiter at the end' do
+        start_text = "<<<<<<< README.md\n=======\n"
+
+        expect { parse_text(start_text) }.
+          to raise_error(Gitlab::Conflict::Parser::MissingEndDelimiter)
+
+        expect { parse_text(start_text + '>>>>>>> some-other-path.md') }.
+          to raise_error(Gitlab::Conflict::Parser::MissingEndDelimiter)
+      end
+    end
+
+    context 'when lines is blank' do
+      it { expect(parser.parse('', 'README.md', 'README.md')).to eq([]) }
+      it { expect(parser.parse(nil, 'README.md', 'README.md')).to eq([]) }
+    end
+  end
+end
diff --git a/spec/support/test_env.rb b/spec/support/test_env.rb
index 1c0c66969e3..976b1f36270 100644
--- a/spec/support/test_env.rb
+++ b/spec/support/test_env.rb
@@ -19,6 +19,8 @@ module TestEnv
     'orphaned-branch'       => '45127a9',
     'binary-encoding'       => '7b1cf43',
     'gitattributes'         => '5a62481',
+    'conflict-a'            => 'dfdd207',
+    'conflict-b'            => '4e75a62',
     'expand-collapse-diffs' => '4842455',
     'expand-collapse-files' => '025db92',
     'expand-collapse-lines' => '238e82d',

From a1c79612172ce07c7b0de4c01fba8fa7369c71de Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Wed, 27 Jul 2016 12:42:18 +0100
Subject: [PATCH 14/90] Handle multiple merge conflict files in collection

---
 .../projects/merge_requests_controller.rb     | 28 +-------
 lib/gitlab/conflict/file.rb                   | 18 ++---
 lib/gitlab/conflict/file_collection.rb        | 59 +++++++++++++++++
 lib/gitlab/conflict/parser.rb                 |  8 +--
 .../merge_requests_controller_spec.rb         | 65 +++++++++++++++++++
 .../gitlab/conflict/file_collection_spec.rb   | 24 +++++++
 spec/lib/gitlab/conflict/file_spec.rb         | 13 ++--
 spec/lib/gitlab/conflict/parser_spec.rb       | 10 +--
 8 files changed, 172 insertions(+), 53 deletions(-)
 create mode 100644 lib/gitlab/conflict/file_collection.rb
 create mode 100644 spec/lib/gitlab/conflict/file_collection_spec.rb

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 689c9627762..fda8a9ea2e3 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -135,33 +135,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
 
     respond_to do |format|
       format.html { render 'show' }
-      format.json do
-        rugged = @merge_request.project.repository.rugged
-        their_commit = rugged.branches[@merge_request.target_branch].target
-        our_commit = rugged.lookup(@merge_request.diff_head_sha)
-        merge = rugged.merge_commits(our_commit, their_commit)
-        commit_message = "Merge branch '#{@merge_request.target_branch}' into '#{@merge_request.source_branch}'\n\n# Conflicts:"
-
-        files = merge.conflicts.map do |conflict|
-          their_path = conflict[:theirs][:path]
-          our_path = conflict[:ours][:path]
-
-          raise 'path mismatch!' unless their_path == our_path
-
-          commit_message << "\n#   #{our_path}"
-          merge_file = merge.merge_file(our_path)
-
-          Gitlab::Conflict::File.new(merge_file, conflict, @merge_request.target_branch, @merge_request.source_branch, @merge_request.project.repository)
-        end
-
-        render json: {
-          target_branch: @merge_request.target_branch,
-          source_branch: @merge_request.source_branch,
-          commit_sha: @merge_request.diff_head_sha,
-          commit_message: commit_message,
-          files: files
-        }
-      end
+      format.json { render json: Gitlab::Conflict::FileCollection.new(@merge_request) }
     end
   end
 
diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 84d3e6f4e03..7f81c72431d 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -3,20 +3,22 @@ module Gitlab
     class File
       CONTEXT_LINES = 3
 
-      attr_reader :merge_file, :their_path, :their_ref, :our_path, :our_ref, :repository
+      attr_reader :merge_file_result, :their_path, :their_ref, :our_path, :our_ref, :repository
 
-      def initialize(merge_file, conflict, their_ref, our_ref, repository)
-        @merge_file = merge_file
+      def initialize(merge_file_result, conflict, diff_refs:, repository:)
+        @merge_file_result = merge_file_result
         @their_path = conflict[:theirs][:path]
         @our_path = conflict[:ours][:path]
-        @their_ref = their_ref
-        @our_ref = our_ref
+        @their_ref = diff_refs.start_sha
+        @our_ref = diff_refs.head_sha
         @repository = repository
       end
 
       # Array of Gitlab::Diff::Line objects
       def lines
-        @lines ||= Gitlab::Conflict::Parser.new.parse(merge_file[:data], their_path, our_path)
+        @lines ||= Gitlab::Conflict::Parser.new.parse(merge_file_result[:data],
+                                                      our_path: our_path,
+                                                      their_path: their_path)
       end
 
       def highlighted_lines
@@ -28,9 +30,9 @@ module Gitlab
         @highlighted_lines = lines.map do |line|
           line = line.dup
           if line.type == 'old'
-            line.rich_text = their_highlight[line.old_line - 1].delete("\n")
+            line.rich_text = their_highlight[line.old_line - 1]
           else
-            line.rich_text = our_highlight[line.new_line - 1].delete("\n")
+            line.rich_text = our_highlight[line.new_line - 1]
           end
           line
         end
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
new file mode 100644
index 00000000000..a3035a5c3e6
--- /dev/null
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -0,0 +1,59 @@
+module Gitlab
+  module Conflict
+    class FileCollection
+      attr_reader :merge_request, :our_commit, :their_commit
+
+      def initialize(merge_request)
+        @merge_request = merge_request
+        @our_commit = merge_request.diff_head_commit.raw.raw_commit
+        @their_commit = merge_request.target_branch_head.raw.raw_commit
+      end
+
+      def repository
+        merge_request.project.repository
+      end
+
+      def merge_index
+        @merge_index ||= repository.rugged.merge_commits(our_commit, their_commit)
+      end
+
+      def files
+        @files ||= merge_index.conflicts.map do |conflict|
+          their_path = conflict[:theirs][:path]
+          our_path = conflict[:ours][:path]
+
+          # TODO remove this
+          raise 'path mismatch!' unless their_path == our_path
+
+          Gitlab::Conflict::File.new(merge_index.merge_file(our_path),
+                                     conflict,
+                                     diff_refs: merge_request.diff_refs,
+                                     repository: repository)
+        end
+      end
+
+      def as_json(opts = nil)
+        {
+          target_branch: merge_request.target_branch,
+          source_branch: merge_request.source_branch,
+          commit_sha: merge_request.diff_head_sha,
+          commit_message: default_commit_message,
+          files: files
+        }
+      end
+
+      def default_commit_message
+        conflict_filenames = merge_index.conflicts.map do |conflict|
+          "#   #{conflict[:ours][:path]}"
+        end
+
+        <<EOM.chomp
+Merge branch '#{merge_request.source_branch}' into '#{merge_request.target_branch}'
+
+# Conflicts:
+#{conflict_filenames.join("\n")}
+EOM
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/conflict/parser.rb b/lib/gitlab/conflict/parser.rb
index a233c268070..9c541931680 100644
--- a/lib/gitlab/conflict/parser.rb
+++ b/lib/gitlab/conflict/parser.rb
@@ -7,7 +7,7 @@ module Gitlab
       class MissingEndDelimiter < StandardError
       end
 
-      def parse(text, their_path, our_path)
+      def parse(text, our_path:, their_path:)
         return [] if text.blank?
 
         line_obj_index = 0
@@ -46,14 +46,10 @@ module Gitlab
           end
         end
 
-        raise MissingEndDelimiter unless type == nil
+        raise MissingEndDelimiter unless type.nil?
 
         lines
       end
-
-      def empty?
-        @lines.empty?
-      end
     end
   end
 end
diff --git a/spec/controllers/projects/merge_requests_controller_spec.rb b/spec/controllers/projects/merge_requests_controller_spec.rb
index 69758494543..2cb89d71589 100644
--- a/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -523,4 +523,69 @@ describe Projects::MergeRequestsController do
       end
     end
   end
+
+  describe 'GET conflicts' do
+    let(:merge_request_with_conflicts) do
+      create(:merge_request, source_branch: 'conflict-a', target_branch: 'conflict-b', source_project: project) do |mr|
+        mr.mark_as_unmergeable
+      end
+    end
+
+    context 'as JSON' do
+      before do
+        get :conflicts,
+            namespace_id: merge_request_with_conflicts.project.namespace.to_param,
+            project_id: merge_request_with_conflicts.project.to_param,
+            id: merge_request_with_conflicts.iid,
+            format: 'json'
+      end
+
+      let(:json_response) { JSON.parse(response.body) }
+
+      it 'includes meta info about the MR' do
+        expect(json_response['commit_message']).to include('Merge branch')
+        expect(json_response['commit_sha']).to match(/\h{40}/)
+        expect(json_response['source_branch']).to eq(merge_request_with_conflicts.source_branch)
+        expect(json_response['target_branch']).to eq(merge_request_with_conflicts.target_branch)
+      end
+
+      it 'includes each file that has conflicts' do
+        filenames = json_response['files'].map { |file| file['new_path'] }
+
+        expect(filenames).to contain_exactly('files/ruby/popen.rb', 'files/ruby/regex.rb')
+      end
+
+      it 'splits files into sections with lines' do
+        json_response['files'].each do |file|
+          file['sections'].each do |section|
+            expect(section).to include('conflict', 'lines')
+
+            section['lines'].each do |line|
+              if section['conflict']
+                expect(line['type']).to be_in(['old', 'new'])
+                expect(line.values_at('old_line', 'new_line')).to contain_exactly(nil, a_kind_of(Integer))
+              else
+                if line['type'].nil?
+                  expect(line['old_line']).not_to eq(nil)
+                  expect(line['new_line']).not_to eq(nil)
+                else
+                  expect(line['type']).to eq('match')
+                  expect(line['old_line']).to eq(nil)
+                  expect(line['new_line']).to eq(nil)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      it 'has unique section IDs across files' do
+        section_ids = json_response['files'].flat_map do |file|
+          file['sections'].map { |section| section['id'] }.compact
+        end
+
+        expect(section_ids.uniq).to eq(section_ids)
+      end
+    end
+  end
 end
diff --git a/spec/lib/gitlab/conflict/file_collection_spec.rb b/spec/lib/gitlab/conflict/file_collection_spec.rb
new file mode 100644
index 00000000000..2a09adb2321
--- /dev/null
+++ b/spec/lib/gitlab/conflict/file_collection_spec.rb
@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Gitlab::Conflict::FileCollection, lib: true do
+  let(:merge_request) { create(:merge_request, source_branch: 'conflict-a', target_branch: 'conflict-b') }
+  let(:file_collection) { Gitlab::Conflict::FileCollection.new(merge_request) }
+
+  describe '#files' do
+    it 'returns an array of Conflict::Files' do
+      expect(file_collection.files).to all(be_an_instance_of(Gitlab::Conflict::File))
+    end
+  end
+
+  describe '#default_commit_message' do
+    it 'matches the format of the git CLI commit message' do
+      expect(file_collection.default_commit_message).to eq(<<EOM.chomp)
+Merge branch 'conflict-a' into 'conflict-b'
+
+# Conflicts:
+#   files/ruby/popen.rb
+#   files/ruby/regex.rb
+EOM
+    end
+  end
+end
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index 318d0d249d6..a9f2fed83aa 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -4,24 +4,21 @@ describe Gitlab::Conflict::File, lib: true do
   let(:project) { create(:project) }
   let(:repository) { project.repository }
   let(:rugged) { repository.rugged }
-  let(:their_ref) { their_commit.oid }
   let(:their_commit) { rugged.branches['conflict-a'].target }
-  let(:our_ref) { our_commit.oid }
+  let(:diff_refs) { Gitlab::Diff::DiffRefs.new(base_sha: their_commit.oid, head_sha: our_commit.oid) }
   let(:our_commit) { rugged.branches['conflict-b'].target }
   let(:index) { rugged.merge_commits(our_commit, their_commit) }
   let(:conflict) { index.conflicts.last }
-  let(:merge_file) { index.merge_file('files/ruby/regex.rb') }
-  let(:conflict_file) { Gitlab::Conflict::File.new(merge_file, conflict, their_ref, our_ref, repository) }
+  let(:merge_file_result) { index.merge_file('files/ruby/regex.rb') }
+  let(:conflict_file) { Gitlab::Conflict::File.new(merge_file_result, conflict, diff_refs: diff_refs, repository: repository) }
 
   describe '#highlighted_lines' do
     def html_to_text(html)
-      CGI.unescapeHTML(ActionView::Base.full_sanitizer.sanitize(html))
+      CGI.unescapeHTML(ActionView::Base.full_sanitizer.sanitize(html)).delete("\n")
     end
 
     it 'returns lines with rich_text' do
-      conflict_file.highlighted_lines.each do |line|
-        expect(line).to have_attributes(rich_text: an_instance_of(String))
-      end
+      expect(conflict_file.highlighted_lines).to all(have_attributes(rich_text: a_kind_of(String)))
     end
 
     it 'returns lines with rich_text matching the text content of the line' do
diff --git a/spec/lib/gitlab/conflict/parser_spec.rb b/spec/lib/gitlab/conflict/parser_spec.rb
index 335da58e13c..1eda14f3e26 100644
--- a/spec/lib/gitlab/conflict/parser_spec.rb
+++ b/spec/lib/gitlab/conflict/parser_spec.rb
@@ -82,7 +82,9 @@ end
 CONFLICT
       end
 
-      let(:lines) { parser.parse(text, 'files/ruby/regex.rb', 'files/ruby/regex.rb') }
+      let(:lines) do
+        parser.parse(text, our_path: 'files/ruby/regex.rb', their_path: 'files/ruby/regex.rb')
+      end
 
       it 'sets our lines as new lines' do
         expect(lines[8..13]).to all(have_attributes(type: 'new'))
@@ -117,7 +119,7 @@ CONFLICT
       let(:path) { 'README.md' }
 
       def parse_text(text)
-        parser.parse(text, path, path)
+        parser.parse(text, our_path: path, their_path: path)
       end
 
       it 'raises UnexpectedDelimiter when there is a non-start delimiter first' do
@@ -171,8 +173,8 @@ CONFLICT
     end
 
     context 'when lines is blank' do
-      it { expect(parser.parse('', 'README.md', 'README.md')).to eq([]) }
-      it { expect(parser.parse(nil, 'README.md', 'README.md')).to eq([]) }
+      it { expect(parser.parse('', our_path: 'README.md', their_path: 'README.md')).to eq([]) }
+      it { expect(parser.parse(nil, our_path: 'README.md', their_path: 'README.md')).to eq([]) }
     end
   end
 end

From 14a4b17d1c8a43c77b0459fd543be36838031610 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Wed, 27 Jul 2016 17:54:04 +0100
Subject: [PATCH 15/90] Allow resolving conflicts in MR controller

---
 .../projects/merge_requests_controller.rb     |  9 ++-
 config/routes.rb                              |  1 +
 lib/gitlab/conflict/file.rb                   | 44 ++++++++++++-
 lib/gitlab/conflict/file_collection.rb        | 20 ++++++
 .../merge_requests_controller_spec.rb         | 39 +++++++++--
 spec/lib/gitlab/conflict/file_spec.rb         | 66 +++++++++++++++++++
 6 files changed, 171 insertions(+), 8 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index fda8a9ea2e3..e36163dd143 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -10,7 +10,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
   before_action :module_enabled
   before_action :merge_request, only: [
     :edit, :update, :show, :diffs, :commits, :conflicts, :builds, :merge, :merge_check,
-    :ci_status, :toggle_subscription, :cancel_merge_when_build_succeeds, :remove_wip
+    :ci_status, :toggle_subscription, :cancel_merge_when_build_succeeds, :remove_wip, :resolve_conflicts
   ]
   before_action :validates_merge_request, only: [:show, :diffs, :commits, :builds]
   before_action :define_show_vars, only: [:show, :diffs, :commits, :conflicts, :builds]
@@ -139,6 +139,13 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     end
   end
 
+  def resolve_conflicts
+    Gitlab::Conflict::FileCollection.new(@merge_request).resolve_conflicts!(params[:merge_request], nil, user: current_user)
+
+    redirect_to namespace_project_merge_request_path(@project.namespace, @project, @merge_request),
+      notice: 'Merge conflicts resolved. The merge request can now be merged.'
+  end
+
   def builds
     respond_to do |format|
       format.html do
diff --git a/config/routes.rb b/config/routes.rb
index 7df9726bc8e..93da084b64a 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -728,6 +728,7 @@ Rails.application.routes.draw do
             post :toggle_award_emoji
             post :remove_wip
             get :diff_for_path
+            post :resolve_conflicts
           end
 
           collection do
diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 7f81c72431d..80f6f7feecf 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -1,6 +1,9 @@
 module Gitlab
   module Conflict
     class File
+      class MissingResolution < StandardError
+      end
+
       CONTEXT_LINES = 3
 
       attr_reader :merge_file_result, :their_path, :their_ref, :our_path, :our_ref, :repository
@@ -21,6 +24,39 @@ module Gitlab
                                                       their_path: their_path)
       end
 
+      def resolve!(resolution, index:, rugged:)
+        new_file = resolve_lines(resolution).map(&:text).join("\n")
+
+        oid = rugged.write(new_file, :blob)
+        our_mode = index.conflict_get(our_path)[:ours][:mode]
+        index.add(path: our_path, oid: oid, mode: our_mode)
+        index.conflict_remove(our_path)
+      end
+
+      def resolve_lines(resolution)
+        current_section = nil
+
+        lines.map do |line|
+          unless line.type
+            current_section = nil
+            next line
+          end
+
+          current_section ||= resolution[line_code(line)]
+
+          case current_section
+          when 'ours'
+            next unless line.type == 'new'
+          when 'theirs'
+            next unless line.type == 'old'
+          else
+            raise MissingResolution
+          end
+
+          line
+        end.compact
+      end
+
       def highlighted_lines
         return @highlighted_lines if @highlighted_lines
 
@@ -77,10 +113,16 @@ module Gitlab
             match_line.text = "@@ -#{match_line.old_pos},#{lines.last.old_pos} +#{match_line.new_pos},#{lines.last.new_pos} @@"
           end
 
-          section || { conflict: !no_conflict, lines: lines }
+          section ||= { conflict: !no_conflict, lines: lines }
+          section[:id] = line_code(lines.first) unless no_conflict
+          section
         end
       end
 
+      def line_code(line)
+        Gitlab::Diff::LineCode.generate(our_path, line.new_pos, line.old_pos)
+      end
+
       def as_json(opts = nil)
         {
           old_path: their_path,
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index a3035a5c3e6..a4a1505bb7d 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -17,6 +17,26 @@ module Gitlab
         @merge_index ||= repository.rugged.merge_commits(our_commit, their_commit)
       end
 
+      def resolve_conflicts!(resolutions, commit_message, user:)
+        rugged = repository.rugged
+        committer = repository.user_to_committer(user)
+        commit_message ||= default_commit_message
+
+        files.each do |file|
+          file.resolve!(resolutions, index: merge_index, rugged: rugged)
+        end
+
+        new_tree = merge_index.write_tree(rugged)
+
+        Rugged::Commit.create(rugged,
+                              author: committer,
+                              committer: committer,
+                              tree: new_tree,
+                              message: commit_message,
+                              parents: [our_commit, their_commit],
+                              update_ref: Gitlab::Git::BRANCH_REF_PREFIX + merge_request.source_branch)
+      end
+
       def files
         @files ||= merge_index.conflicts.map do |conflict|
           their_path = conflict[:theirs][:path]
diff --git a/spec/controllers/projects/merge_requests_controller_spec.rb b/spec/controllers/projects/merge_requests_controller_spec.rb
index 2cb89d71589..a876a440ab8 100644
--- a/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -4,6 +4,11 @@ describe Projects::MergeRequestsController do
   let(:project) { create(:project) }
   let(:user)    { create(:user) }
   let(:merge_request) { create(:merge_request_with_diffs, target_project: project, source_project: project) }
+  let(:merge_request_with_conflicts) do
+    create(:merge_request, source_branch: 'conflict-a', target_branch: 'conflict-b', source_project: project) do |mr|
+      mr.mark_as_unmergeable
+    end
+  end
 
   before do
     sign_in(user)
@@ -525,12 +530,6 @@ describe Projects::MergeRequestsController do
   end
 
   describe 'GET conflicts' do
-    let(:merge_request_with_conflicts) do
-      create(:merge_request, source_branch: 'conflict-a', target_branch: 'conflict-b', source_project: project) do |mr|
-        mr.mark_as_unmergeable
-      end
-    end
-
     context 'as JSON' do
       before do
         get :conflicts,
@@ -588,4 +587,32 @@ describe Projects::MergeRequestsController do
       end
     end
   end
+
+  context 'POST resolve_conflicts' do
+    def resolve_conflicts(params)
+      post :resolve_conflicts,
+           namespace_id: merge_request_with_conflicts.project.namespace.to_param,
+           project_id: merge_request_with_conflicts.project.to_param,
+           id: merge_request_with_conflicts.iid,
+           format: 'json',
+           merge_request: params
+    end
+
+    context 'with valid params' do
+      before do
+        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_4_4' => 'ours',
+                          '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_9_9' => 'ours',
+                          '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_21_21' => 'theirs',
+                          '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_49_49' => 'theirs')
+      end
+
+      it 'creates a new commit on the branch' do
+        expect(merge_request_with_conflicts.source_branch_head.message).to include('Merge branch')
+      end
+
+      it 'redirects to the MR show page' do
+        expect(response).to redirect_to([merge_request_with_conflicts.target_project.namespace.becomes(Namespace), merge_request_with_conflicts.target_project, merge_request_with_conflicts])
+      end
+    end
+  end
 end
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index a9f2fed83aa..afdb52daf43 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -12,6 +12,57 @@ describe Gitlab::Conflict::File, lib: true do
   let(:merge_file_result) { index.merge_file('files/ruby/regex.rb') }
   let(:conflict_file) { Gitlab::Conflict::File.new(merge_file_result, conflict, diff_refs: diff_refs, repository: repository) }
 
+  describe '#resolve_lines' do
+    let(:section_keys) { conflict_file.sections.map { |section| section[:id] }.compact }
+
+    context 'when resolving everything to the same side' do
+      let(:resolution_hash) { section_keys.map { |key| [key, 'ours'] }.to_h }
+      let(:resolved_lines) { conflict_file.resolve_lines(resolution_hash) }
+      let(:expected_lines) { conflict_file.lines.reject { |line| line.type == 'old' } }
+
+      it 'has the correct number of lines' do
+        expect(resolved_lines.length).to eq(expected_lines.length)
+      end
+
+      it 'has content matching the chosen lines' do
+        expect(resolved_lines.map(&:text)).to eq(expected_lines.map(&:text))
+      end
+    end
+
+    context 'with mixed resolutions' do
+      let(:resolution_hash) do
+        section_keys.map.with_index { |key, i| [key, i.even? ? 'ours' : 'theirs'] }.to_h
+      end
+
+      let(:resolved_lines) { conflict_file.resolve_lines(resolution_hash) }
+
+      it 'has the correct number of lines' do
+        file_lines = conflict_file.lines.reject { |line| line.type == 'new' }
+
+        expect(resolved_lines.length).to eq(file_lines.length)
+      end
+
+      it 'returns a file containing only the chosen parts of the resolved sections' do
+        expect(resolved_lines.chunk { |line| line.type || 'both' }.map(&:first)).
+          to eq(['both', 'new', 'both', 'old', 'both', 'new', 'both'])
+      end
+    end
+
+    it 'raises MissingResolution when passed a hash without resolutions for all sections' do
+      empty_hash = section_keys.map { |key| [key, nil] }.to_h
+      invalid_hash = section_keys.map { |key| [key, 'invalid'] }.to_h
+
+      expect { conflict_file.resolve_lines({}) }.
+        to raise_error(Gitlab::Conflict::File::MissingResolution)
+
+      expect { conflict_file.resolve_lines(empty_hash) }.
+        to raise_error(Gitlab::Conflict::File::MissingResolution)
+
+      expect { conflict_file.resolve_lines(invalid_hash) }.
+        to raise_error(Gitlab::Conflict::File::MissingResolution)
+    end
+  end
+
   describe '#highlighted_lines' do
     def html_to_text(html)
       CGI.unescapeHTML(ActionView::Base.full_sanitizer.sanitize(html)).delete("\n")
@@ -69,5 +120,20 @@ describe Gitlab::Conflict::File, lib: true do
         end
       end
     end
+
+    it 'adds unique IDs to conflict sections, and not to other sections' do
+      section_ids = []
+
+      conflict_file.sections.each do |section|
+        if section[:conflict]
+          expect(section).to have_key(:id)
+          section_ids << section[:id]
+        else
+          expect(section).not_to have_key(:id)
+        end
+      end
+
+      expect(section_ids.uniq).to eq(section_ids)
+    end
   end
 end

From 10321bf862135b946d50918e89bc4667e8d9071d Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Fri, 29 Jul 2016 12:15:10 +0300
Subject: [PATCH 16/90] Fixes for merge conflicts UI.

---
 app/assets/javascripts/merge_conflict_resolver.js.coffee    | 6 +++---
 app/assets/stylesheets/pages/merge_conflicts.scss           | 1 +
 app/views/projects/merge_requests/show/_conflicts.html.haml | 4 ++--
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.coffee b/app/assets/javascripts/merge_conflict_resolver.js.coffee
index 47ff8b7825b..cc68d847abb 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.coffee
+++ b/app/assets/javascripts/merge_conflict_resolver.js.coffee
@@ -120,10 +120,10 @@ class window.MergeConflictResolver extends Vue
 
           if conflict
             if line.type is 'old'
-              line = { lineType: 'conflict', lineNumber: line.old_line, richText: line.rich_text, section: 'origin', id, isSelected: no, isUnselected: no, isOrigin: yes }
+              line = { lineType: 'conflict', lineNumber: line.old_line, richText: line.rich_text, section: 'head', id, isSelected: no, isUnselected: no, isHead: yes }
               file.parallelLines.left.push  line
             else if line.type is 'new'
-              line = { lineType: 'conflict', lineNumber: line.new_line, richText: line.rich_text, section: 'head', id, isSelected: no, isUnselected: no, isHead: yes }
+              line = { lineType: 'conflict', lineNumber: line.new_line, richText: line.rich_text, section: 'origin', id, isSelected: no, isUnselected: no, isOrigin: yes }
               file.parallelLines.right.push line
             else
               console.log 'unhandled line type...', line
@@ -155,7 +155,7 @@ class window.MergeConflictResolver extends Vue
 
     for file in data.files
       for section in file.sections when section.conflict
-        @$set "resolutionData.#{section.id}", no
+        @$set "resolutionData['#{section.id}']", no
 
 
   getInitialData: ->
diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index f55134f968c..0e306c26541 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -16,6 +16,7 @@ $unselected_line:         #F8F8F8;
 
   .diff-wrap-lines .line_content {
     white-space: normal;
+    min-height: 19px;
   }
 
   .head {
diff --git a/app/views/projects/merge_requests/show/_conflicts.html.haml b/app/views/projects/merge_requests/show/_conflicts.html.haml
index d40f231cf53..7491786c34a 100644
--- a/app/views/projects/merge_requests/show/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/show/_conflicts.html.haml
@@ -43,14 +43,14 @@
               %template{"v-if" => "line.isHeader"}
                 %td.diff-line-num.header
                 %td.line_content.header
-                  %strong {{line.text}}
+                  %strong {{line.richText}}
                   %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
 
               %template{"v-if" => "!line.isHeader"}
                 %td.diff-line-num.old_line
                   {{line.lineNumber}}
                 %td.line_content
-                  {{{line.text}}}
+                  {{{line.richText}}}
 
   .files{"v-if" => "!isParallel"}
     .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}

From 28ef06c52b3d76b2e5dc60b0bdcf407162035ee8 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 29 Jul 2016 11:05:33 +0100
Subject: [PATCH 17/90] Fix merge conflict reading for new diffs

---
 app/models/merge_request.rb            | 4 ++--
 lib/gitlab/conflict/file_collection.rb | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/app/models/merge_request.rb b/app/models/merge_request.rb
index f6d0d0c98f5..e87ce322098 100644
--- a/app/models/merge_request.rb
+++ b/app/models/merge_request.rb
@@ -204,7 +204,7 @@ class MergeRequest < ActiveRecord::Base
 
   def diff_start_commit
     if persisted?
-      merge_request_diff.start_commit
+      merge_request_diff.start_commit || target_branch_head
     else
       target_branch_head
     end
@@ -212,7 +212,7 @@ class MergeRequest < ActiveRecord::Base
 
   def diff_head_commit
     if persisted?
-      merge_request_diff.head_commit
+      merge_request_diff.head_commit || source_branch_head
     else
       source_branch_head
     end
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index a4a1505bb7d..695dafa9e20 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -5,7 +5,7 @@ module Gitlab
 
       def initialize(merge_request)
         @merge_request = merge_request
-        @our_commit = merge_request.diff_head_commit.raw.raw_commit
+        @our_commit = merge_request.source_branch_head.raw.raw_commit
         @their_commit = merge_request.target_branch_head.raw.raw_commit
       end
 

From d77216356a686029410c16d35775e42ef81a0e64 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 29 Jul 2016 11:16:31 +0100
Subject: [PATCH 18/90] Fix commit tab initial load

---
 app/controllers/projects/merge_requests_controller.rb | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index e36163dd143..3205d7cb8e4 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -134,7 +134,11 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     return render_404 unless @merge_request.cannot_be_merged?
 
     respond_to do |format|
-      format.html { render 'show' }
+      format.html do
+        define_discussion_vars
+        render 'show'
+      end
+
       format.json { render json: Gitlab::Conflict::FileCollection.new(@merge_request) }
     end
   end

From 7af277f683cd5ee0d5e3ffbc1dd3ce1d61f17848 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 29 Jul 2016 13:29:14 +0100
Subject: [PATCH 19/90] Auto-highlight conflict when rich_text is called

---
 lib/gitlab/conflict/file.rb           | 13 +++++--------
 lib/gitlab/conflict/parser.rb         |  6 +++---
 lib/gitlab/diff/line.rb               | 11 +++++++++--
 spec/lib/gitlab/conflict/file_spec.rb | 16 +++++++++++-----
 4 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 80f6f7feecf..9ba8ae0367f 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -21,7 +21,8 @@ module Gitlab
       def lines
         @lines ||= Gitlab::Conflict::Parser.new.parse(merge_file_result[:data],
                                                       our_path: our_path,
-                                                      their_path: their_path)
+                                                      their_path: their_path,
+                                                      parent: self)
       end
 
       def resolve!(resolution, index:, rugged:)
@@ -57,27 +58,23 @@ module Gitlab
         end.compact
       end
 
-      def highlighted_lines
-        return @highlighted_lines if @highlighted_lines
-
+      def highlight_lines!
         their_highlight = Gitlab::Highlight.highlight_lines(repository, their_ref, their_path)
         our_highlight = Gitlab::Highlight.highlight_lines(repository, our_ref, our_path)
 
-        @highlighted_lines = lines.map do |line|
-          line = line.dup
+        lines.each do |line|
           if line.type == 'old'
             line.rich_text = their_highlight[line.old_line - 1]
           else
             line.rich_text = our_highlight[line.new_line - 1]
           end
-          line
         end
       end
 
       def sections
         return @sections if @sections
 
-        chunked_lines = highlighted_lines.chunk { |line| line.type.nil? }
+        chunked_lines = lines.chunk { |line| line.type.nil? }
         match_line = nil
 
         @sections = chunked_lines.flat_map.with_index do |(no_conflict, lines), i|
diff --git a/lib/gitlab/conflict/parser.rb b/lib/gitlab/conflict/parser.rb
index 9c541931680..0aa85202d56 100644
--- a/lib/gitlab/conflict/parser.rb
+++ b/lib/gitlab/conflict/parser.rb
@@ -7,7 +7,7 @@ module Gitlab
       class MissingEndDelimiter < StandardError
       end
 
-      def parse(text, our_path:, their_path:)
+      def parse(text, our_path:, their_path:, parent: nil)
         return [] if text.blank?
 
         line_obj_index = 0
@@ -36,9 +36,9 @@ module Gitlab
             type = nil
           elsif line[0] == '\\'
             type = 'nonewline'
-            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new)
+            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new, parent: parent)
           else
-            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new)
+            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new, parent: parent)
             line_old += 1 if type != 'new'
             line_new += 1 if type != 'old'
 
diff --git a/lib/gitlab/diff/line.rb b/lib/gitlab/diff/line.rb
index 5196051f90d..38400b48b5c 100644
--- a/lib/gitlab/diff/line.rb
+++ b/lib/gitlab/diff/line.rb
@@ -2,12 +2,13 @@ module Gitlab
   module Diff
     class Line
       attr_reader :type, :index, :old_pos, :new_pos
+      attr_writer :rich_text
       attr_accessor :text
-      attr_accessor :rich_text
 
-      def initialize(text, type, index, old_pos, new_pos)
+      def initialize(text, type, index, old_pos, new_pos, parent: nil)
         @text, @type, @index = text, type, index
         @old_pos, @new_pos = old_pos, new_pos
+        @parent = parent
       end
 
       def self.init_from_hash(hash)
@@ -44,6 +45,12 @@ module Gitlab
         type == 'old'
       end
 
+      def rich_text
+        @parent.highlight_lines! if @parent && !@rich_text
+
+        @rich_text
+      end
+
       def meta?
         type == 'match' || type == 'nonewline'
       end
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index afdb52daf43..735b5b34623 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -63,17 +63,23 @@ describe Gitlab::Conflict::File, lib: true do
     end
   end
 
-  describe '#highlighted_lines' do
+  describe '#highlight_lines!' do
     def html_to_text(html)
       CGI.unescapeHTML(ActionView::Base.full_sanitizer.sanitize(html)).delete("\n")
     end
 
-    it 'returns lines with rich_text' do
-      expect(conflict_file.highlighted_lines).to all(have_attributes(rich_text: a_kind_of(String)))
+    it 'modifies the existing lines' do
+      expect { conflict_file.highlight_lines! }.to change { conflict_file.lines.map(&:instance_variables) }
     end
 
-    it 'returns lines with rich_text matching the text content of the line' do
-      conflict_file.highlighted_lines.each do |line|
+    it 'is called implicitly when rich_text is accessed on a line' do
+      expect(conflict_file).to receive(:highlight_lines!).once.and_call_original
+
+      conflict_file.lines.each(&:rich_text)
+    end
+
+    it 'sets the rich_text of the lines matching the text content' do
+      conflict_file.lines.each do |line|
         expect(line.text).to eq(html_to_text(line.rich_text))
       end
     end

From 97ceadeea7b3ad9fa69049932149157334beba11 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 29 Jul 2016 14:49:48 +0100
Subject: [PATCH 20/90] Fix MR conflict resolution commits

---
 lib/gitlab/conflict/file_collection.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index 695dafa9e20..46e381d2661 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -33,7 +33,7 @@ module Gitlab
                               committer: committer,
                               tree: new_tree,
                               message: commit_message,
-                              parents: [our_commit, their_commit],
+                              parents: [our_commit, their_commit].map(&:oid),
                               update_ref: Gitlab::Git::BRANCH_REF_PREFIX + merge_request.source_branch)
       end
 

From f2f844693ecd8a10d48530adf8d59a7c125d2752 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 29 Jul 2016 14:51:11 +0100
Subject: [PATCH 21/90] Handle conflict resolution errors in controller

---
 .../projects/merge_requests_controller.rb     | 18 +++++--
 lib/gitlab/conflict/file.rb                   | 10 ++--
 lib/gitlab/conflict/parser.rb                 |  7 ++-
 .../merge_requests_controller_spec.rb         | 47 ++++++++++++++++++-
 4 files changed, 69 insertions(+), 13 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 3205d7cb8e4..6772672992c 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -139,15 +139,25 @@ class Projects::MergeRequestsController < Projects::ApplicationController
         render 'show'
       end
 
-      format.json { render json: Gitlab::Conflict::FileCollection.new(@merge_request) }
+      format.json do
+        begin
+          render json: Gitlab::Conflict::FileCollection.new(@merge_request)
+        rescue Gitlab::Conflict::Parser::ParserError => e
+          render json: { message: 'Unable to resolve conflicts in the web interface for this merge request' }
+        end
+      end
     end
   end
 
   def resolve_conflicts
-    Gitlab::Conflict::FileCollection.new(@merge_request).resolve_conflicts!(params[:merge_request], nil, user: current_user)
+    begin
+      Gitlab::Conflict::FileCollection.new(@merge_request).resolve_conflicts!(params[:merge_request], nil, user: current_user)
 
-    redirect_to namespace_project_merge_request_path(@project.namespace, @project, @merge_request),
-      notice: 'Merge conflicts resolved. The merge request can now be merged.'
+      redirect_to namespace_project_merge_request_path(@project.namespace, @project, @merge_request),
+                  notice: 'Merge conflicts resolved. The merge request can now be merged.'
+    rescue Gitlab::Conflict::File::MissingResolution => e
+      render status: :bad_request, json: { message: e.message }
+    end
   end
 
   def builds
diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 9ba8ae0367f..598bf2a2612 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -35,23 +35,23 @@ module Gitlab
       end
 
       def resolve_lines(resolution)
-        current_section = nil
+        section_id = nil
 
         lines.map do |line|
           unless line.type
-            current_section = nil
+            section_id = nil
             next line
           end
 
-          current_section ||= resolution[line_code(line)]
+          section_id ||= line_code(line)
 
-          case current_section
+          case resolution[section_id]
           when 'ours'
             next unless line.type == 'new'
           when 'theirs'
             next unless line.type == 'old'
           else
-            raise MissingResolution
+            raise MissingResolution, "Missing resolution for section ID: #{section_id}"
           end
 
           line
diff --git a/lib/gitlab/conflict/parser.rb b/lib/gitlab/conflict/parser.rb
index 0aa85202d56..8ab7b6499aa 100644
--- a/lib/gitlab/conflict/parser.rb
+++ b/lib/gitlab/conflict/parser.rb
@@ -1,10 +1,13 @@
 module Gitlab
   module Conflict
     class Parser
-      class UnexpectedDelimiter < StandardError
+      class ParserError < StandardError
       end
 
-      class MissingEndDelimiter < StandardError
+      class UnexpectedDelimiter < ParserError
+      end
+
+      class MissingEndDelimiter < ParserError
       end
 
       def parse(text, our_path:, their_path:, parent: nil)
diff --git a/spec/controllers/projects/merge_requests_controller_spec.rb b/spec/controllers/projects/merge_requests_controller_spec.rb
index a876a440ab8..bca5d8c0655 100644
--- a/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -530,8 +530,13 @@ describe Projects::MergeRequestsController do
   end
 
   describe 'GET conflicts' do
-    context 'as JSON' do
+    let(:json_response) { JSON.parse(response.body) }
+
+    context 'when the conflicts cannot be resolved in the UI' do
       before do
+        allow_any_instance_of(Gitlab::Conflict::Parser).
+          to receive(:parse).and_raise(Gitlab::Conflict::Parser::UnexpectedDelimiter)
+
         get :conflicts,
             namespace_id: merge_request_with_conflicts.project.namespace.to_param,
             project_id: merge_request_with_conflicts.project.to_param,
@@ -539,7 +544,23 @@ describe Projects::MergeRequestsController do
             format: 'json'
       end
 
-      let(:json_response) { JSON.parse(response.body) }
+      it 'returns a 200 status code' do
+        expect(response).to have_http_status(:ok)
+      end
+
+      it 'returns JSON with a message' do
+        expect(json_response.keys).to contain_exactly('message')
+      end
+    end
+
+    context 'with valid conflicts' do
+      before do
+        get :conflicts,
+            namespace_id: merge_request_with_conflicts.project.namespace.to_param,
+            project_id: merge_request_with_conflicts.project.to_param,
+            id: merge_request_with_conflicts.iid,
+            format: 'json'
+      end
 
       it 'includes meta info about the MR' do
         expect(json_response['commit_message']).to include('Merge branch')
@@ -589,6 +610,9 @@ describe Projects::MergeRequestsController do
   end
 
   context 'POST resolve_conflicts' do
+    let(:json_response) { JSON.parse(response.body) }
+    let!(:original_head_sha) { merge_request_with_conflicts.diff_head_sha }
+
     def resolve_conflicts(params)
       post :resolve_conflicts,
            namespace_id: merge_request_with_conflicts.project.namespace.to_param,
@@ -607,6 +631,7 @@ describe Projects::MergeRequestsController do
       end
 
       it 'creates a new commit on the branch' do
+        expect(original_head_sha).not_to eq(merge_request_with_conflicts.source_branch_head.sha)
         expect(merge_request_with_conflicts.source_branch_head.message).to include('Merge branch')
       end
 
@@ -614,5 +639,23 @@ describe Projects::MergeRequestsController do
         expect(response).to redirect_to([merge_request_with_conflicts.target_project.namespace.becomes(Namespace), merge_request_with_conflicts.target_project, merge_request_with_conflicts])
       end
     end
+
+    context 'when sections are missing' do
+      before do
+        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_4_4' => 'ours')
+      end
+
+      it 'returns a 400 error' do
+        expect(response).to have_http_status(:bad_request)
+      end
+
+      it 'has a message with the name of the first missing section' do
+        expect(json_response['message']).to include('6eb14e00385d2fb284765eb1cd8d420d33d63fc9_9_9')
+      end
+
+      it 'does not create a new commit' do
+        expect(original_head_sha).to eq(merge_request_with_conflicts.source_branch_head.sha)
+      end
+    end
   end
 end

From 18398152fa4e5237a7b682d955457b12a7d59b31 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 29 Jul 2016 15:17:06 +0100
Subject: [PATCH 22/90] Raise errors for large and binary files

---
 lib/gitlab/conflict/parser.rb           |  6 +++++-
 spec/lib/gitlab/conflict/parser_spec.rb | 26 ++++++++++++++++---------
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/lib/gitlab/conflict/parser.rb b/lib/gitlab/conflict/parser.rb
index 8ab7b6499aa..9f27cba353a 100644
--- a/lib/gitlab/conflict/parser.rb
+++ b/lib/gitlab/conflict/parser.rb
@@ -10,8 +10,12 @@ module Gitlab
       class MissingEndDelimiter < ParserError
       end
 
+      class UnmergeableFile < ParserError
+      end
+
       def parse(text, our_path:, their_path:, parent: nil)
-        return [] if text.blank?
+        raise UnmergeableFile if text.blank? # Typically a binary file
+        raise UnmergeableFile if text.length > 102400
 
         line_obj_index = 0
         line_old = 1
diff --git a/spec/lib/gitlab/conflict/parser_spec.rb b/spec/lib/gitlab/conflict/parser_spec.rb
index 1eda14f3e26..65a828accde 100644
--- a/spec/lib/gitlab/conflict/parser_spec.rb
+++ b/spec/lib/gitlab/conflict/parser_spec.rb
@@ -4,6 +4,10 @@ describe Gitlab::Conflict::Parser, lib: true do
   let(:parser) { Gitlab::Conflict::Parser.new }
 
   describe '#parse' do
+    def parse_text(text)
+      parser.parse(text, our_path: 'README.md', their_path: 'README.md')
+    end
+
     context 'when the file has valid conflicts' do
       let(:text) do
         <<CONFLICT
@@ -116,12 +120,6 @@ CONFLICT
     end
 
     context 'when the file contents include conflict delimiters' do
-      let(:path) { 'README.md' }
-
-      def parse_text(text)
-        parser.parse(text, our_path: path, their_path: path)
-      end
-
       it 'raises UnexpectedDelimiter when there is a non-start delimiter first' do
         expect { parse_text('=======') }.
           to raise_error(Gitlab::Conflict::Parser::UnexpectedDelimiter)
@@ -172,9 +170,19 @@ CONFLICT
       end
     end
 
-    context 'when lines is blank' do
-      it { expect(parser.parse('', our_path: 'README.md', their_path: 'README.md')).to eq([]) }
-      it { expect(parser.parse(nil, our_path: 'README.md', their_path: 'README.md')).to eq([]) }
+    context 'other file types' do
+      it 'raises UnmergeableFile when lines is blank, indicating a binary file' do
+        expect { parse_text('') }.
+          to raise_error(Gitlab::Conflict::Parser::UnmergeableFile)
+
+        expect { parse_text(nil) }.
+          to raise_error(Gitlab::Conflict::Parser::UnmergeableFile)
+      end
+
+      it 'raises UnmergeableFile when the file is over 100 KB' do
+        expect { parse_text('a' * 102401) }.
+          to raise_error(Gitlab::Conflict::Parser::UnmergeableFile)
+      end
     end
   end
 end

From f0bbfe7a62f8005188a46b25184c7f32eb098d14 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 29 Jul 2016 16:37:51 +0100
Subject: [PATCH 23/90] Add match line headers

---
 lib/gitlab/conflict/file.rb | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 598bf2a2612..bbabcf265f3 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -75,11 +75,17 @@ module Gitlab
         return @sections if @sections
 
         chunked_lines = lines.chunk { |line| line.type.nil? }
+        last_candidate_match_header = nil
+        match_line_header = nil
         match_line = nil
 
         @sections = chunked_lines.flat_map.with_index do |(no_conflict, lines), i|
           section = nil
 
+          lines.each do |line|
+            last_candidate_match_header = " #{line.text}" if line.text.match(/\A[A-Za-z$_]/)
+          end
+
           if no_conflict
             conflict_before = i > 0
             conflict_after = chunked_lines.peek
@@ -88,6 +94,7 @@ module Gitlab
               if lines.length > CONTEXT_LINES * 2
                 tail_lines = lines.last(CONTEXT_LINES)
                 first_tail_line = tail_lines.first
+                match_line_header = last_candidate_match_header
                 match_line = Gitlab::Diff::Line.new('',
                                                     'match',
                                                     first_tail_line.index,
@@ -107,7 +114,7 @@ module Gitlab
           end
 
           if match_line && !section
-            match_line.text = "@@ -#{match_line.old_pos},#{lines.last.old_pos} +#{match_line.new_pos},#{lines.last.new_pos} @@"
+            match_line.text = "@@ -#{match_line.old_pos},#{lines.last.old_pos} +#{match_line.new_pos},#{lines.last.new_pos} @@#{match_line_header}"
           end
 
           section ||= { conflict: !no_conflict, lines: lines }

From 99e00856ebb09b8edc9729b7f21a8005aaf02cb3 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Mon, 1 Aug 2016 11:13:47 +0100
Subject: [PATCH 24/90] REMOVE THIS COMMIT: allow undoing last resolution

---
 .../projects/merge_requests_controller.rb           | 13 ++++++++++++-
 config/routes.rb                                    |  1 +
 .../projects/merge_requests_controller_spec.rb      | 13 +++++++++++++
 3 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 6772672992c..1fbdc73cabe 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -10,7 +10,8 @@ class Projects::MergeRequestsController < Projects::ApplicationController
   before_action :module_enabled
   before_action :merge_request, only: [
     :edit, :update, :show, :diffs, :commits, :conflicts, :builds, :merge, :merge_check,
-    :ci_status, :toggle_subscription, :cancel_merge_when_build_succeeds, :remove_wip, :resolve_conflicts
+    :ci_status, :toggle_subscription, :cancel_merge_when_build_succeeds, :remove_wip, :resolve_conflicts,
+    :undo_last_resolution
   ]
   before_action :validates_merge_request, only: [:show, :diffs, :commits, :builds]
   before_action :define_show_vars, only: [:show, :diffs, :commits, :conflicts, :builds]
@@ -160,6 +161,16 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     end
   end
 
+  def undo_last_resolution
+    rugged = @merge_request.project.repository.rugged
+    ref = Gitlab::Git::BRANCH_REF_PREFIX + @merge_request.source_branch
+    prev = rugged.ref(ref).target
+
+    rugged.references.update(ref, prev.parents.first.oid) if prev.parents.length == 2
+
+    head :ok
+  end
+
   def builds
     respond_to do |format|
       format.html do
diff --git a/config/routes.rb b/config/routes.rb
index 93da084b64a..91d33ea43e9 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -729,6 +729,7 @@ Rails.application.routes.draw do
             post :remove_wip
             get :diff_for_path
             post :resolve_conflicts
+            post :undo_last_resolution
           end
 
           collection do
diff --git a/spec/controllers/projects/merge_requests_controller_spec.rb b/spec/controllers/projects/merge_requests_controller_spec.rb
index bca5d8c0655..226650399cc 100644
--- a/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -638,6 +638,19 @@ describe Projects::MergeRequestsController do
       it 'redirects to the MR show page' do
         expect(response).to redirect_to([merge_request_with_conflicts.target_project.namespace.becomes(Namespace), merge_request_with_conflicts.target_project, merge_request_with_conflicts])
       end
+
+      context 'undoing the resolution' do
+        before do
+          post :undo_last_resolution,
+               namespace_id: merge_request_with_conflicts.project.namespace.to_param,
+               project_id: merge_request_with_conflicts.project.to_param,
+               id: merge_request_with_conflicts.iid
+        end
+
+        it 'undoes the commit' do
+          expect(original_head_sha).to eq(merge_request_with_conflicts.source_branch_head.sha)
+        end
+      end
     end
 
     context 'when sections are missing' do

From 4d8b0293aed69b6c379be3be63d5f05fd3a7106b Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Mon, 1 Aug 2016 11:15:28 +0100
Subject: [PATCH 25/90] Remove unneeded raise

---
 lib/gitlab/conflict/file_collection.rb | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index 46e381d2661..e621a76a7de 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -42,9 +42,6 @@ module Gitlab
           their_path = conflict[:theirs][:path]
           our_path = conflict[:ours][:path]
 
-          # TODO remove this
-          raise 'path mismatch!' unless their_path == our_path
-
           Gitlab::Conflict::File.new(merge_index.merge_file(our_path),
                                      conflict,
                                      diff_refs: merge_request.diff_refs,

From 0267a64556613c0515b0f51674f0b7301ac89289 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Sun, 31 Jul 2016 18:24:22 +0300
Subject: [PATCH 26/90] Remove CS MergeConflictResolver class.

---
 .../merge_conflict_resolver.js.coffee         | 171 --------
 .../javascripts/merge_conflicts_data.coffee   | 405 ------------------
 2 files changed, 576 deletions(-)
 delete mode 100644 app/assets/javascripts/merge_conflict_resolver.js.coffee
 delete mode 100644 app/assets/javascripts/merge_conflicts_data.coffee

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.coffee b/app/assets/javascripts/merge_conflict_resolver.js.coffee
deleted file mode 100644
index cc68d847abb..00000000000
--- a/app/assets/javascripts/merge_conflict_resolver.js.coffee
+++ /dev/null
@@ -1,171 +0,0 @@
-#= require lib/vue
-
-class window.MergeConflictResolver extends Vue
-
-  constructor: (options = {}) ->
-
-    options.el       = '#conflicts'
-    options.data     = @getInitialData()
-    options.name     = 'MergeConflictResolver'
-    options.created  = -> @fetchData()
-    options.computed =
-      conflictsCount : -> @getConflictsCount()
-      resolvedCount  : -> @getResolvedCount()
-      allResolved    : -> @isAllResolved()
-
-    super options
-
-    window.v = this
-
-
-  fetchData: ->
-
-    $.ajax
-      url    : './conflicts.json'
-      success: (response) =>
-        @handleResponse response
-
-
-  handleResponse: (data) ->
-
-    @isLoading     = no
-    @conflictsData = @decorateData data
-
-
-  handleViewTypeChange: (newType) ->
-
-    return if newType is @diffView
-    return unless newType in [ 'parallel', 'inline' ]
-
-    @diffView = newType
-    $.cookie 'diff_view', newType
-    @isParallel = @diffView is 'parallel'
-
-    # FIXME: Maybe even better with vue.js
-    $('.container-fluid').toggleClass 'container-limited'
-
-
-  handleSelected: (sectionId, selection) ->
-
-    @resolutionData[sectionId] = selection
-
-    #FIXME: Dry!!
-    for file in @conflictsData.files
-      for line in file.inlineLines
-        if line.id is sectionId and (line.conflict or line.isHeader)
-          if selection is 'head' and line.isHead
-            line.isSelected = yes
-            line.isUnselected = no
-          else if selection is 'origin' and line.isOrigin
-            line.isSelected = yes
-            line.isUnselected = no
-          else
-            line.isUnselected = yes
-            line.isSelected = no
-
-      for section, lines of file.parallelLines
-        for line in lines
-          if line.id is sectionId and (line.lineType is 'conflict' or line.isHeader)
-            if selection is 'head' and line.isHead
-              line.isSelected = yes
-              line.isUnselected = no
-            else if selection is 'origin' and line.isOrigin
-              line.isSelected = yes
-              line.isUnselected = no
-            else
-              line.isUnselected = yes
-              line.isSelected = no
-
-
-  decorateData: (data) ->
-
-    headHeaderText   = 'HEAD//our changes'
-    originHeaderText = 'origin//their changes'
-    data.shortCommitSha = data.commit_sha.slice 0, 7
-    data.commitMessage = data.commit_message
-
-    @updateResolutionsData data
-
-    # FIXME: Add comments and separate parallel and inline data decoration
-    for file in data.files
-      file.parallelLines  = { left: [], right: [] }
-      file.inlineLines    = []
-      currentLineType     = 'old'
-
-      for section in file.sections
-        { conflict, lines, id } = section
-
-        if conflict
-          # FIXME: Make these lines better
-          file.parallelLines.left.push  { isHeader: yes, id, richText: headHeaderText, section: 'head', isHead: yes, isSelected: no, isUnselected: no }
-          file.parallelLines.right.push { isHeader: yes, id, richText: originHeaderText, section: 'origin', isOrigin: yes, isSelected: no, isUnselected: no }
-
-          file.inlineLines.push { isHeader: yes, id, richText: headHeaderText, type: 'old', section: 'head', isHead: yes, isSelected: no, isUnselected: no }
-
-        for line in lines
-          if line.type in ['new', 'old'] and currentLineType isnt line.type
-            currentLineType = line.type
-            # FIXME: Find a better way to add a new line
-            file.inlineLines.push { lineType: 'emptyLine', richText: '<span> </span>' }
-
-          # FIXME: Make these lines better
-          line.conflict = conflict
-          line.id = id
-          line.isHead = line.type is 'new'
-          line.isOrigin = line.type is 'old'
-          line.isSelected = no
-          line.isUnselected = no
-          line.richText = line.rich_text
-          file.inlineLines.push line
-
-          if conflict
-            if line.type is 'old'
-              line = { lineType: 'conflict', lineNumber: line.old_line, richText: line.rich_text, section: 'head', id, isSelected: no, isUnselected: no, isHead: yes }
-              file.parallelLines.left.push  line
-            else if line.type is 'new'
-              line = { lineType: 'conflict', lineNumber: line.new_line, richText: line.rich_text, section: 'origin', id, isSelected: no, isUnselected: no, isOrigin: yes }
-              file.parallelLines.right.push line
-            else
-              console.log 'unhandled line type...', line
-          else
-            file.parallelLines.left.push  { lineType: 'context', lineNumber: line.old_line, richText: line.rich_text }
-            file.parallelLines.right.push { lineType: 'context', lineNumber: line.new_line, richText: line.rich_text }
-
-        if conflict
-          file.inlineLines.push { isHeader: yes, id, type: 'new', richText: originHeaderText, section: 'origin', isOrigin: yes, isSelected: no, isUnselected: no }
-
-    return data
-
-
-  getConflictsCount: -> return Object.keys(@resolutionData).length
-
-
-  getResolvedCount: ->
-
-    count = 0
-    count++ for id, resolution of @resolutionData when resolution
-
-    return count
-
-
-  isAllResolved: -> return @resolvedCount is @conflictsCount
-
-
-  updateResolutionsData: (data) ->
-
-    for file in data.files
-      for section in file.sections when section.conflict
-        @$set "resolutionData['#{section.id}']", no
-
-
-  getInitialData: ->
-
-    diffViewType = $.cookie 'diff_view'
-
-    return {
-      isLoading      : yes
-      isParallel     : diffViewType is 'parallel'
-      diffView       : diffViewType
-      conflictsData  : {}
-      resolutionData : {}
-    }
diff --git a/app/assets/javascripts/merge_conflicts_data.coffee b/app/assets/javascripts/merge_conflicts_data.coffee
deleted file mode 100644
index 7d89a87cf14..00000000000
--- a/app/assets/javascripts/merge_conflicts_data.coffee
+++ /dev/null
@@ -1,405 +0,0 @@
-window.mergeConflictsData = {
-  "target_branch": "master",
-  "source_branch": "mc-ui",
-  "commit_sha": "b5fa56eb3f2cea5e21c68b43c7c22b5b96e0e7b3",
-  "files": [
-    {
-      "old_path": "lib/component.js",
-      "new_path": "lib/component.js",
-      "sections": [
-        {
-          "conflict": false,
-          "lines": [
-            {
-              "type": null,
-              "old_line": 206,
-              "new_line": 206,
-              "text": ""
-            },
-            {
-              "type": null,
-              "old_line": 207,
-              "new_line": 207,
-              "text": "var options = utils.merge.apply(utils, args);"
-            }
-          ]
-        },
-        {
-          "conflict": true,
-          "id": "section123",
-          "lines": [
-            {
-              "type": "old",
-              "old_line": 208,
-              "new_line": null,
-              "text": "$(selector).each(function(i, rawNode) {"
-            },
-            {
-              "type": "old",
-              "old_line": 209,
-              "new_line": null,
-              "text": "var componentInfo = registry.findComponentInfo(this)"
-            },
-            {
-              "type": "old",
-              "old_line": 210,
-              "new_line": null,
-              "text": "if (componentInfo && componentInfo.isAttachedTo(rawNode)) {"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 208,
-              "text": "$(selector).each(function(i, node) {"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 209,
-              "text": "if (componentInfo && componentInfo.isAttachedTo(node)) {"
-            }
-          ]
-        },
-        {
-          "conflict": false,
-          "lines": [
-            {
-              "type": null,
-              "old_line": 211,
-              "new_line": 210,
-              "text": "return;"
-            },
-            {
-              "type": null,
-              "old_line": 212,
-              "new_line": 211,
-              "text": "}"
-            },
-            {
-              "type": null,
-              "old_line": null,
-              "new_line": 212,
-              "text": ""
-            },
-            {
-              "type": null,
-              "old_line": 213,
-              "new_line": 213,
-              "text": ""
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "commit_sha": "b5fa56eb3f2cea5e21c68b43c7c22b5b96e0e7b3",
-      "old_path": "lib/component.js",
-      "new_path": "lib/component.js",
-      "sections": [
-        {
-          "conflict": false,
-          "lines": [
-            {
-              "type": null,
-              "old_line": 62,
-              "new_line": 62,
-              "text": "        (new this).initialize(node, options);"
-            },
-            {
-              "type": null,
-              "old_line": 63,
-              "new_line": 63,
-              "text": "      }.bind(this));"
-            },
-            {
-              "type": null,
-              "old_line": 64,
-              "new_line": 64,
-              "text": "    }"
-            },
-            {
-              "type": null,
-              "old_line": 65,
-              "new_line": 65,
-              "text": ""
-            }
-          ]
-        },
-        {
-          "conflict": true,
-          "id": "section124",
-          "lines": [
-            {
-              "type": "old",
-              "old_line": 67,
-              "new_line": null,
-              "text": "    function removeFrom(selector) {"
-            },
-            {
-              "type": "old",
-              "old_line": 68,
-              "new_line": null,
-              "text": "      if (!selector) {"
-            },
-            {
-              "type": "old",
-              "old_line": 69,
-              "new_line": null,
-              "text": "        throw new Error(\"Component needs to be removeFrom'd a jQuery object, native node or selector string\");"
-            },
-            {
-              "type": "old",
-              "old_line": 70,
-              "new_line": null,
-              "text": "      }"
-            },
-            {
-              "type": "old",
-              "old_line": 71,
-              "new_line": null,
-              "text": " "
-            },
-            {
-              "type": "old",
-              "old_line": 72,
-              "new_line": null,
-              "text": "      $(selector).each(function(i, rawNode) {"
-            },
-            {
-              "type": "old",
-              "old_line": 73,
-              "new_line": null,
-              "text": "        var componentInfo = registry.findComponentInfo(this)"
-            },
-            {
-              "type": "old",
-              "old_line": 74,
-              "new_line": null,
-              "text": "        if (componentInfo && componentInfo.isAttachedTo(rawNode)) {"
-            },
-            {
-              "type": "old",
-              "old_line": 75,
-              "new_line": null,
-              "text": "          Object.keys(componentInfo.instances).forEach(function(index) {"
-            },
-            {
-              "type": "old",
-              "old_line": 76,
-              "new_line": null,
-              "text": "            var instance = componentInfo.instances[index].instance;"
-            },
-            {
-              "type": "old",
-              "old_line": 77,
-              "new_line": null,
-              "text": "            if (instance.node === rawNode) {"
-            },
-            {
-              "type": "old",
-              "old_line": 78,
-              "new_line": null,
-              "text": "              instance.teardown();"
-            },
-            {
-              "type": "old",
-              "old_line": 79,
-              "new_line": null,
-              "text": "            }"
-            },
-            {
-              "type": "old",
-              "old_line": 80,
-              "new_line": null,
-              "text": "          });"
-            },
-            {
-              "type": "old",
-              "old_line": 81,
-              "new_line": null,
-              "text": "        }"
-            },
-            {
-              "type": "old",
-              "old_line": 82,
-              "new_line": null,
-              "text": "      }.bind(this));"
-            },
-            {
-              "type": "old",
-              "old_line": 83,
-              "new_line": null,
-              "text": "    }"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 67,
-              "text": "    function prettyPrintMixins() {"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 68,
-              "text": "      //could be called from constructor or constructor.prototype"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 69,
-              "text": "      var mixedIn = this.mixedIn || this.prototype.mixedIn || [];"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 70,
-              "text": "      return mixedIn.map(function(mixin) {"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 71,
-              "text": "        if (mixin.name == null) {"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 72,
-              "text": "          // function name property not supported by this browser, use regex"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 73,
-              "text": "          var m = mixin.toString().match(functionNameRegEx);"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 74,
-              "text": "          return (m && m[1]) ? m[1] : '';"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 75,
-              "text": "        } else {"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 76,
-              "text": "          return (mixin.name != 'withBase') ? mixin.name : '';"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 77,
-              "text": "        }"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 78,
-              "text": "      }).filter(Boolean).join(', ');"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 79,
-              "text": "    };"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 80,
-              "text": ""
-            }
-          ]
-        },
-        {
-          "conflict": false,
-          "lines": [
-            {
-              "type": null,
-              "old_line": 84,
-              "new_line": 81,
-              "text": ""
-            },
-            {
-              "type": null,
-              "old_line": 85,
-              "new_line": 82,
-              "text": "    // define the constructor for a custom component type"
-            },
-            {
-              "type": null,
-              "old_line": 86,
-              "new_line": 83,
-              "text": "    // takes an unlimited number of mixin functions as arguments"
-            },
-            {
-              "type": null,
-              "old_line": 87,
-              "new_line": 84,
-              "text": "    // typical api call with 3 mixins: define(timeline, withTweetCapability, withScrollCapability);"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "commit_sha": "c68b43c7c22b5b96e0e7b3b5fa56eb3f2cea5e21",
-      "old_path": "lib/registry.js",
-      "new_path": "lib/registry.js",
-      "sections": [
-        {
-          "conflict": false,
-          "lines": [
-            {
-              "type": null,
-              "old_line": 159,
-              "new_line": 159,
-              "text": ""
-            },
-            {
-              "type": null,
-              "old_line": 160,
-              "new_line": 160,
-              "text": "var thisInstanceInfo = this.allInstances[k]"
-            }
-          ]
-        },
-        {
-          "conflict": true,
-          "id": "section125",
-          "lines": [
-            {
-              "type": "old",
-              "old_line": 161,
-              "new_line": null,
-              "text": "if(thisInstanceInfo.instance.node == node){"
-            },
-            {
-              "type": "new",
-              "old_line": null,
-              "new_line": 161,
-              "text": "if (thisInstanceInfo.instance.node === node) {"
-            }
-          ]
-        },
-        {
-          "conflict": false,
-          "lines": [
-            {
-              "type": null,
-              "old_line": 162,
-              "new_line": 162,
-              "text": "result.push(thisInstanceInfo);"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}

From 5c7a7093b719b5f4be6630c4861b745d8252d07c Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Sun, 31 Jul 2016 18:24:51 +0300
Subject: [PATCH 27/90] Added ES6 MergeConflictResolver classes.

---
 app/assets/javascripts/dispatcher.js          |   2 +
 .../merge_conflict_data_provider.js.es6       | 231 ++++++++++++++++++
 .../merge_conflict_resolver.js.es6            |  47 ++++
 app/assets/javascripts/merge_request_tabs.js  |   2 +-
 4 files changed, 281 insertions(+), 1 deletion(-)
 create mode 100644 app/assets/javascripts/merge_conflict_data_provider.js.es6
 create mode 100644 app/assets/javascripts/merge_conflict_resolver.js.es6

diff --git a/app/assets/javascripts/dispatcher.js b/app/assets/javascripts/dispatcher.js
index 3946e861976..12a34a276d3 100644
--- a/app/assets/javascripts/dispatcher.js
+++ b/app/assets/javascripts/dispatcher.js
@@ -86,6 +86,8 @@
           new ZenMode();
           new MergedButtons();
           break;
+        case "projects:merge_requests:conflicts":
+          window.mcui = new MergeConflictResolver()
         case 'projects:merge_requests:index':
           shortcut_handler = new ShortcutsNavigation();
           Issuable.init();
diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
new file mode 100644
index 00000000000..ceb3422c577
--- /dev/null
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -0,0 +1,231 @@
+const HEAD_HEADER_TEXT   = 'HEAD//our changes';
+const ORIGIN_HEADER_TEXT = 'origin//their changes';
+
+window.MergeConflictDataProvider = class MergeConflictDataProvider {
+
+  getInitialData() {
+    const diffViewType = $.cookie('diff_view');
+
+    return {
+      isLoading      : true,
+      isParallel     : diffViewType === 'parallel',
+      diffViewType   : diffViewType,
+      conflictsData  : {},
+      resolutionData : {}
+    }
+  }
+
+
+  decorateData(vueInstance, data) {
+    this.vueInstance    = vueInstance;
+    data.shortCommitSha = data.commit_sha.slice(0, 7);
+    data.commitMesage   = data.commit_message;
+
+    this.setParallelLines(data);
+    this.setInlineLines(data);
+    this.updateResolutionsData(data);
+
+    vueInstance.conflictsData = data;
+  }
+
+
+  updateResolutionsData(data) {
+    const vi = this.vueInstance;
+
+    data.files.forEach( (file) => {
+      file.sections.forEach( (section) => {
+        if (section.conflict) {
+          vi.$set(`resolutionData['${section.id}']`, false);
+        }
+      });
+    });
+  }
+
+
+  setParallelLines(data) {
+    data.files.forEach( (file) => {
+      file.parallelLines = { left: [], right: [] };
+
+      file.sections.forEach( (section) => {
+        const { conflict, lines, id } = section;
+
+        if (conflict) {
+          file.parallelLines.left.push(this.getOriginHeaderLine(id));
+          file.parallelLines.right.push(this.getHeadHeaderLine(id));
+        }
+
+        lines.forEach( (line) => {
+          const { type } = line;
+          if (conflict) {
+            if (type === 'old') {
+              line = { lineType: 'conflict', hasConflict: true, lineNumber: line.old_line, richText: line.rich_text, section: 'head', id, isSelected: false, isUnselected: false, isOrigin: true }
+              file.parallelLines.left.push(line);
+            }
+            else if (type === 'new') {
+              line = { lineType: 'conflict', hasConflict: true, lineNumber: line.new_line, richText: line.rich_text, section: 'origin', id, isSelected: false, isUnselected: false, isHead: true }
+              file.parallelLines.right.push(line);
+            }
+          }
+          else {
+            file.parallelLines.left.push({ lineType: 'context', lineNumber: line.old_line, richText: line.rich_text });
+            file.parallelLines.right.push({ lineType: 'context', lineNumber: line.new_line, richText: line.rich_text });
+          }
+        });
+      });
+    });
+  }
+
+
+  setInlineLines(data) {
+    data.files.forEach( (file) => {
+      file.inlineLines = []
+
+      file.sections.forEach( (section) => {
+        let currentLineType = 'new';
+        const { conflict, lines, id } = section;
+
+        if (conflict) {
+          file.inlineLines.push(this.getHeadHeaderLine(id));
+        }
+
+        lines.forEach( (line) => {
+          const { type } = line;
+
+          if ((type === 'new' || type === 'old') && currentLineType !== type) {
+            currentLineType = type;
+            file.inlineLines.push({ lineType: 'emptyLine', richText: '' });
+          }
+
+          this.decorateLineForInlineView(line, id, conflict);
+          file.inlineLines.push(line);
+        })
+
+        if (conflict) {
+          file.inlineLines.push(this.getOriginHeaderLine(id));
+        }
+      });
+    });
+  }
+
+
+  handleSelected(sectionId, selection) {
+    const vi = this.vueInstance;
+
+    vi.resolutionData[sectionId] = selection;
+    vi.conflictsData.files.forEach( (file) => {
+      file.inlineLines.forEach( (line) => {
+        if (line.id === sectionId && (line.hasConflict || line.isHeader)) {
+          this.markLine(line, selection);
+        }
+      });
+
+
+      for (section in file.parallelLines) {
+        const lines = file.parallelLines[section];
+
+        lines.forEach( (line) => {
+          if (line.id === sectionId && (line.hasConflict || line.isHeader )) {
+            this.markLine(line, selection);
+          }
+        })
+      }
+    });
+  }
+
+
+  updateViewType(newType) {
+    const vi = this.vueInstance;
+
+    if (newType === vi.diffView || !(newType === 'parallel' || newType === 'inline')) {
+      return;
+    }
+
+    vi.diffView   = newType;
+    vi.isParallel = newType === 'parallel';
+    $.cookie('diff_view', newType); // TODO: Make sure that cookie path added.
+    $('.container-fluid').toggleClass('container-limited');
+  }
+
+
+  markLine(line, selection) {
+    if (selection === 'head' && line.isHead) {
+      line.isSelected   = true;
+      line.isUnselected = false;
+    }
+    else if (selection === 'origin' && line.isOrigin) {
+      line.isSelected   = true;
+      line.isUnselected = false;
+    }
+    else {
+      line.isSelected   = false;
+      line.isUnselected = true;
+    }
+  }
+
+
+  getConflictsCount() {
+    return Object.keys(this.vueInstance.resolutionData).length;
+  }
+
+
+  getResolvedCount() {
+    let  count = 0;
+    const data = this.vueInstance.resolutionData;
+
+    for (const id in data) {
+      const resolution = data[id];
+      if (resolution) {
+        count++;
+      }
+    }
+
+    return count;
+  }
+
+
+  isAllResolved() {
+    return this.getConflictsCount() === this.getResolvedCount();
+  }
+
+
+  decorateLineForInlineView(line, id, conflict) {
+    const { type }    = line;
+    line.id           = id;
+    line.hasConflict  = conflict;
+    line.isHead       = type === 'new';
+    line.isOrigin     = type === 'old';
+    line.hasMatch     = type === 'match';
+    line.richText     = line.rich_text;
+    line.isSelected   = false;
+    line.isUnselected = false;
+  }
+
+
+  getHeadHeaderLine(id) {
+    return {
+      id          : id,
+      richText    : HEAD_HEADER_TEXT,
+      type        : 'new',
+      section     : 'head',
+      isHeader    : true,
+      isHead      : true,
+      isSelected  : false,
+      isUnselected: false
+    }
+  }
+
+
+  getOriginHeaderLine(id) {
+    return {
+      id          : id,
+      richText    : ORIGIN_HEADER_TEXT,
+      type        : 'old',
+      section     : 'origin',
+      isHeader    : true,
+      isOrigin    : true,
+      isSelected  : false,
+      isUnselected: false
+    }
+  }
+
+}
diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
new file mode 100644
index 00000000000..63b27f49ce1
--- /dev/null
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -0,0 +1,47 @@
+//= require lib/vue
+
+window.MergeConflictResolver = class MergeConflictResolver {
+  constructor() {
+    this.dataProvider = new MergeConflictDataProvider()
+    this.initVue()
+  }
+
+  initVue() {
+    const that = this;
+    this.vue   = new Vue({
+      el       : '#conflicts',
+      name     : 'MergeConflictResolver',
+      data     : this.dataProvider.getInitialData(),
+      created  : this.fetchData(),
+      computed : this.setComputedProperties(),
+      methods  : {
+        handleSelected(sectionId, selection) {
+          that.dataProvider.handleSelected(sectionId, selection);
+        },
+        handleViewTypeChange(newType) {
+          that.dataProvider.updateViewType(newType);
+        }
+      }
+    })
+  }
+
+
+  fetchData() {
+    $.get('./conflicts.json').done( (data) => {
+      this.dataProvider.decorateData(this.vue, data);
+      this.vue.isLoading = false;
+    })
+  }
+
+
+  setComputedProperties() {
+    const dp = this.dataProvider;
+
+    return {
+      conflictsCount() { return dp.getConflictsCount() },
+      resolvedCount()  { return dp.getResolvedCount() },
+      allResolved()    { return dp.isAllResolved() }
+    }
+  }
+
+}
diff --git a/app/assets/javascripts/merge_request_tabs.js b/app/assets/javascripts/merge_request_tabs.js
index 52c2ed61012..e038abe378c 100644
--- a/app/assets/javascripts/merge_request_tabs.js
+++ b/app/assets/javascripts/merge_request_tabs.js
@@ -81,7 +81,7 @@
       if (action === 'show') {
         action = 'notes';
       }
-      new_state = this._location.pathname.replace(/\/(commits|diffs|builds)(\.html)?\/?$/, '');
+      new_state = this._location.pathname.replace(/\/(commits|diffs|builds|conflicts)(\.html)?\/?$/, '');
       if (action !== 'notes') {
         new_state += "/" + action;
       }

From c439be58ff389053c892f2a74a72abaaea831a1f Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Sun, 31 Jul 2016 18:25:16 +0300
Subject: [PATCH 28/90] Some minor change on conflicts template.

---
 .../projects/merge_requests/show/_conflicts.html.haml  | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/app/views/projects/merge_requests/show/_conflicts.html.haml b/app/views/projects/merge_requests/show/_conflicts.html.haml
index 7491786c34a..83be422ff35 100644
--- a/app/views/projects/merge_requests/show/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/show/_conflicts.html.haml
@@ -28,7 +28,7 @@
       .file-title
         %span {{file.new_path}}
         .file-actions
-          %a.btn.btn-sm View file @{{conflictsData.shortCommitShab}}
+          %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
 
       .diff-content.diff-wrap-lines
         .diff-wrap-lines.code.file-content.js-syntax-highlight.white
@@ -37,6 +37,7 @@
               ":class" => "{ |
                 'head': line.isHead, |
                 'origin': line.isOrigin, |
+                'match': line.hasMatch, |
                 'selected': line.isSelected, |
                 'unselected': line.isUnselected }"}
 
@@ -66,16 +67,17 @@
               ":class" => "{ |
                 'head': line.isHead, |
                 'origin': line.isOrigin, |
+                'match': line.hasMatch, |
                 'selected': line.isSelected, |
                 'unselected': line.isUnselected }"}
 
               %template{"v-if" => "!line.isHeader"}
-                %td.diff-line-num.old_line
-                  %a {{line.old_line}}
                 %td.diff-line-num.new_line
                   %a {{line.new_line}}
+                %td.diff-line-num.old_line
+                  %a {{line.old_line}}
                 %td.line_content
-                  {{{line.rich_text}}}
+                  {{{line.richText}}}
 
               %template{"v-if" => "line.isHeader"}
                 %td.diff-line-num.header

From 89875afff62c1e81063ae9fbf3c87fb49c75e0f1 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Sun, 31 Jul 2016 18:25:40 +0300
Subject: [PATCH 29/90] Refactor on diff themes for merge conflicts UI.

---
 app/assets/stylesheets/framework/mixins.scss        |  7 ++++++-
 app/assets/stylesheets/highlight/dark.scss          |  7 +++++--
 app/assets/stylesheets/highlight/monokai.scss       |  7 +++++--
 .../stylesheets/highlight/solarized_dark.scss       |  7 +++++--
 .../stylesheets/highlight/solarized_light.scss      | 13 +++++++++++--
 app/assets/stylesheets/highlight/white.scss         | 13 +++++++++++--
 6 files changed, 43 insertions(+), 11 deletions(-)

diff --git a/app/assets/stylesheets/framework/mixins.scss b/app/assets/stylesheets/framework/mixins.scss
index 5ec5a96a597..d2d60ed7196 100644
--- a/app/assets/stylesheets/framework/mixins.scss
+++ b/app/assets/stylesheets/framework/mixins.scss
@@ -123,4 +123,9 @@
       }
     }
   }
-}
\ No newline at end of file
+}
+
+@mixin dark-diff-match-line {
+  color: rgba(255, 255, 255, 0.3);
+  background: rgba(255, 255, 255, 0.1);
+}
diff --git a/app/assets/stylesheets/highlight/dark.scss b/app/assets/stylesheets/highlight/dark.scss
index 77a73dc379b..16ffbe57a99 100644
--- a/app/assets/stylesheets/highlight/dark.scss
+++ b/app/assets/stylesheets/highlight/dark.scss
@@ -21,6 +21,10 @@
 
   // Diff line
   .line_holder {
+    &.match .line_content {
+      @include dark-diff-match-line;
+    }
+
     td.diff-line-num.hll:not(.empty-cell),
     td.line_content.hll:not(.empty-cell) {
       background-color: #557;
@@ -36,8 +40,7 @@
     }
 
     .line_content.match {
-      color: rgba(255, 255, 255, 0.3);
-      background: rgba(255, 255, 255, 0.1);
+      @include dark-diff-match-line;
     }
   }
 
diff --git a/app/assets/stylesheets/highlight/monokai.scss b/app/assets/stylesheets/highlight/monokai.scss
index 80a509a7c1a..7de920e074b 100644
--- a/app/assets/stylesheets/highlight/monokai.scss
+++ b/app/assets/stylesheets/highlight/monokai.scss
@@ -21,6 +21,10 @@
 
   // Diff line
   .line_holder {
+    &.match .line_content {
+      @include dark-diff-match-line;
+    }
+
     td.diff-line-num.hll:not(.empty-cell),
     td.line_content.hll:not(.empty-cell) {
       background-color: #49483e;
@@ -36,8 +40,7 @@
     }
 
     .line_content.match {
-      color: rgba(255, 255, 255, 0.3);
-      background: rgba(255, 255, 255, 0.1);
+      @include dark-diff-match-line;
     }
   }
 
diff --git a/app/assets/stylesheets/highlight/solarized_dark.scss b/app/assets/stylesheets/highlight/solarized_dark.scss
index c62bd021aef..b11499c71ee 100644
--- a/app/assets/stylesheets/highlight/solarized_dark.scss
+++ b/app/assets/stylesheets/highlight/solarized_dark.scss
@@ -21,6 +21,10 @@
 
   // Diff line
   .line_holder {
+    &.match .line_content {
+      @include dark-diff-match-line;
+    }
+
     td.diff-line-num.hll:not(.empty-cell),
     td.line_content.hll:not(.empty-cell) {
       background-color: #174652;
@@ -36,8 +40,7 @@
     }
 
     .line_content.match {
-      color: rgba(255, 255, 255, 0.3);
-      background: rgba(255, 255, 255, 0.1);
+      @include dark-diff-match-line;
     }
   }
 
diff --git a/app/assets/stylesheets/highlight/solarized_light.scss b/app/assets/stylesheets/highlight/solarized_light.scss
index 524cfaf90c3..657bb5e3cd9 100644
--- a/app/assets/stylesheets/highlight/solarized_light.scss
+++ b/app/assets/stylesheets/highlight/solarized_light.scss
@@ -1,4 +1,10 @@
 /* https://gist.github.com/qguv/7936275 */
+
+@mixin matchLine {
+  color: $black-transparent;
+  background: rgba(255, 255, 255, 0.4);
+}
+
 .code.solarized-light {
   // Line numbers
   .line-numbers, .diff-line-num {
@@ -21,6 +27,10 @@
 
   // Diff line
   .line_holder {
+    &.match .line_content {
+      @include matchLine;
+    }
+
     td.diff-line-num.hll:not(.empty-cell),
     td.line_content.hll:not(.empty-cell) {
       background-color: #ddd8c5;
@@ -36,8 +46,7 @@
     }
 
     .line_content.match {
-      color: $black-transparent;
-      background: rgba(255, 255, 255, 0.4);
+      @include matchLine;
     }
   }
 
diff --git a/app/assets/stylesheets/highlight/white.scss b/app/assets/stylesheets/highlight/white.scss
index 31a4e3deaac..36a80a916b2 100644
--- a/app/assets/stylesheets/highlight/white.scss
+++ b/app/assets/stylesheets/highlight/white.scss
@@ -1,4 +1,10 @@
 /* https://github.com/aahan/pygments-github-style */
+
+@mixin matchLine {
+  color: $black-transparent;
+  background-color: $match-line;
+}
+
 .code.white {
   // Line numbers
   .line-numbers, .diff-line-num {
@@ -22,6 +28,10 @@
   // Diff line
   .line_holder {
 
+    &.match .line_content {
+      @include matchLine;
+    }
+
     .diff-line-num {
       &.old {
         background-color: $line-number-old;
@@ -57,8 +67,7 @@
       }
 
       &.match {
-        color: $black-transparent;
-        background-color: $match-line;
+        @include matchLine;
       }
 
       &.hll:not(.empty-cell) {

From 85507b25e40ecbb99ec0e86519d383bea32e0b64 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Sun, 31 Jul 2016 18:31:56 +0300
Subject: [PATCH 30/90] Fixes for match lines in parallel view.

---
 app/assets/javascripts/merge_conflict_data_provider.js.es6 | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index ceb3422c577..37b949948f9 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -67,8 +67,10 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
             }
           }
           else {
-            file.parallelLines.left.push({ lineType: 'context', lineNumber: line.old_line, richText: line.rich_text });
-            file.parallelLines.right.push({ lineType: 'context', lineNumber: line.new_line, richText: line.rich_text });
+            const lineType = line.type || 'context';
+            const hasMatch = line.type === 'match';
+            file.parallelLines.left.push({ lineType, hasMatch, lineNumber: line.old_line, richText: line.rich_text });
+            file.parallelLines.right.push({ lineType, hasMatch, lineNumber: line.new_line, richText: line.rich_text });
           }
         });
       });

From b0b5e9f1618bb2607e60a2c98840f052e042433f Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Sun, 31 Jul 2016 18:46:33 +0300
Subject: [PATCH 31/90] Refactor data parser to remove duplicated objects.

---
 .../merge_conflict_data_provider.js.es6       | 33 ++++++++++++++-----
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 37b949948f9..d2ae3f59da5 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -56,21 +56,19 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
         lines.forEach( (line) => {
           const { type } = line;
+
           if (conflict) {
             if (type === 'old') {
-              line = { lineType: 'conflict', hasConflict: true, lineNumber: line.old_line, richText: line.rich_text, section: 'head', id, isSelected: false, isUnselected: false, isOrigin: true }
-              file.parallelLines.left.push(line);
+              file.parallelLines.left.push(this.getLineForParallelView(line, id, 'conflict'));
             }
             else if (type === 'new') {
-              line = { lineType: 'conflict', hasConflict: true, lineNumber: line.new_line, richText: line.rich_text, section: 'origin', id, isSelected: false, isUnselected: false, isHead: true }
-              file.parallelLines.right.push(line);
+              file.parallelLines.right.push(this.getLineForParallelView(line, id, 'conflict', true));
             }
           }
           else {
-            const lineType = line.type || 'context';
-            const hasMatch = line.type === 'match';
-            file.parallelLines.left.push({ lineType, hasMatch, lineNumber: line.old_line, richText: line.rich_text });
-            file.parallelLines.right.push({ lineType, hasMatch, lineNumber: line.new_line, richText: line.rich_text });
+            const lineType = type || 'context';
+            file.parallelLines.left.push (this.getLineForParallelView(line, id, lineType));
+            file.parallelLines.right.push(this.getLineForParallelView(line, id, lineType));
           }
         });
       });
@@ -202,6 +200,25 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
     line.isUnselected = false;
   }
 
+  getLineForParallelView(line, id, lineType, isHead) {
+    const { old_line, new_line, rich_text } = line;
+    const hasConflict = lineType === 'conflict';
+
+    return {
+      id,
+      lineType,
+      hasConflict,
+      isHead: hasConflict && isHead,
+      isOrigin: hasConflict && !isHead,
+      hasMatch: lineType === 'match',
+      lineNumber: isHead ? new_line : old_line,
+      section: isHead ? 'head' : 'origin',
+      richText: rich_text,
+      isSelected: false,
+      isUnselected: false
+    }
+  }
+
 
   getHeadHeaderLine(id) {
     return {

From 5625e8281aafa417c93d74be9fd0fe65540957c4 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 1 Aug 2016 14:43:57 +0300
Subject: [PATCH 32/90] Check line lengths and fill missing lines with empty
 lines.

---
 .../merge_conflict_data_provider.js.es6       | 41 +++++++++++++++----
 .../merge_conflict_resolver.js.es6            |  2 +
 2 files changed, 34 insertions(+), 9 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index d2ae3f59da5..b1f1e7bd78c 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -67,15 +67,38 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
           }
           else {
             const lineType = type || 'context';
+
             file.parallelLines.left.push (this.getLineForParallelView(line, id, lineType));
-            file.parallelLines.right.push(this.getLineForParallelView(line, id, lineType));
+            file.parallelLines.right.push(this.getLineForParallelView(line, id, lineType, true));
           }
         });
+
+        this.checkLineLengths(file);
       });
     });
   }
 
 
+  checkLineLengths(file) {
+    let { left, right } = file.parallelLines;
+
+    if (left.length !== right.length) {
+      if (left.length > right.length) {
+        const diff = left.length - right.length;
+        for (let i = 0; i < diff; i++) {
+          file.parallelLines.right.push({ lineType: 'emptyLine', richText: '' });
+        }
+      }
+      else {
+        const diff = right.length - left.length;
+        for (let i = 0; i < diff; i++) {
+          file.parallelLines.left.push({ lineType: 'emptyLine', richText: '' });
+        }
+      }
+    }
+  }
+
+
   setInlineLines(data) {
     data.files.forEach( (file) => {
       file.inlineLines = []
@@ -208,14 +231,14 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
       id,
       lineType,
       hasConflict,
-      isHead: hasConflict && isHead,
-      isOrigin: hasConflict && !isHead,
-      hasMatch: lineType === 'match',
-      lineNumber: isHead ? new_line : old_line,
-      section: isHead ? 'head' : 'origin',
-      richText: rich_text,
-      isSelected: false,
-      isUnselected: false
+      isHead       : hasConflict && isHead,
+      isOrigin     : hasConflict && !isHead,
+      hasMatch     : lineType === 'match',
+      lineNumber   : isHead ? new_line : old_line,
+      section      : isHead ? 'head' : 'origin',
+      richText     : rich_text,
+      isSelected   : false,
+      isUnselected : false
     }
   }
 
diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index 63b27f49ce1..76298150767 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -1,11 +1,13 @@
 //= require lib/vue
 
 window.MergeConflictResolver = class MergeConflictResolver {
+
   constructor() {
     this.dataProvider = new MergeConflictDataProvider()
     this.initVue()
   }
 
+
   initVue() {
     const that = this;
     this.vue   = new Vue({

From 66ffa28e65515d48eb5576aa77b5e0668067b53b Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 1 Aug 2016 17:22:26 +0300
Subject: [PATCH 33/90] Remove Conflicts tab make it a page instead.

---
 .../projects/merge_requests_controller.rb     |   5 +-
 .../projects/merge_requests/_show.html.haml   |   7 --
 .../projects/merge_requests/conflicts.haml    | 111 ++++++++++++++++++
 .../merge_requests/show/_conflicts.html.haml  | 103 ----------------
 4 files changed, 112 insertions(+), 114 deletions(-)
 create mode 100644 app/views/projects/merge_requests/conflicts.haml
 delete mode 100644 app/views/projects/merge_requests/show/_conflicts.html.haml

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 1fbdc73cabe..e34f4d102ce 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -135,10 +135,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     return render_404 unless @merge_request.cannot_be_merged?
 
     respond_to do |format|
-      format.html do
-        define_discussion_vars
-        render 'show'
-      end
+      format.html { define_discussion_vars }
 
       format.json do
         begin
diff --git a/app/views/projects/merge_requests/_show.html.haml b/app/views/projects/merge_requests/_show.html.haml
index e5683d5a987..269198adf91 100644
--- a/app/views/projects/merge_requests/_show.html.haml
+++ b/app/views/projects/merge_requests/_show.html.haml
@@ -61,10 +61,6 @@
           = link_to diffs_namespace_project_merge_request_path(@project.namespace, @project, @merge_request), data: {target: 'div#diffs', action: 'diffs', toggle: 'tab'} do
             Changes
             %span.badge= @merge_request.diff_size
-        %li.conflicts-tab
-          = link_to conflicts_namespace_project_merge_request_path(@project.namespace, @project, @merge_request), data: {target: 'div#conflicts', action: 'conflicts', toggle: 'tab'} do
-            Conflicts
-            %span.badge 3
 
       .tab-content
         #notes.notes.tab-pane.voting_notes
@@ -82,9 +78,6 @@
           - # This tab is always loaded via AJAX
         #diffs.diffs.tab-pane
           - # This tab is always loaded via AJAX
-        #conflicts.conflicts.tab-pane
-          - # This tab is always loaded via AJAX
-          = render 'projects/merge_requests/show/conflicts'
 
       .mr-loading-status
         = spinner
diff --git a/app/views/projects/merge_requests/conflicts.haml b/app/views/projects/merge_requests/conflicts.haml
new file mode 100644
index 00000000000..a34a58baad6
--- /dev/null
+++ b/app/views/projects/merge_requests/conflicts.haml
@@ -0,0 +1,111 @@
+- page_title "Merge Conflicts", "#{@merge_request.title} (#{@merge_request.to_reference}", "Merge Requests"
+
+= render "projects/merge_requests/show/mr_title"
+
+.merge-request-details.issuable-details{data: {id: @merge_request.project.id}}
+  = render "projects/merge_requests/show/mr_box"
+
+#conflicts
+  .loading{ "v-if" => "isLoading" }
+    %i.fa.fa-spinner.fa-spin
+
+  .content-block.oneline-block.files-changed{ "v-if" => "!isLoading" }
+    .inline-parallel-buttons
+      .btn-group
+        %a.btn{ |
+          ":class" => "{'active': !isParallel}", |
+          "@click" => "handleViewTypeChange('inline')"}
+          Inline
+        %a.btn{ |
+          ":class" => "{'active': isParallel}", |
+          "@click" => "handleViewTypeChange('parallel')"}
+          Side-by-side
+
+    .js-toggle-container
+      .commit-stat-summary
+        Showing
+        %strong.cred {{conflictsCount}} conflicts
+        for
+        %strong {{conflictsData.source_branch}}
+        into
+        %strong {{conflictsData.target_branch}}
+
+  .files-wrapper{ "v-if" => "!isLoading" }
+    .files{"v-if" => "isParallel"}
+      .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
+        .file-title
+          %span {{file.new_path}}
+          .file-actions
+            %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
+
+        .diff-content.diff-wrap-lines
+          .diff-wrap-lines.code.file-content.js-syntax-highlight.white
+            %table{"v-for" => "(key, group) in file.parallelLines"}
+              %tr.line_holder.parallel{"v-for" => "line in group", |
+                ":class" => "{ |
+                  'head': line.isHead, |
+                  'origin': line.isOrigin, |
+                  'match': line.hasMatch, |
+                  'selected': line.isSelected, |
+                  'unselected': line.isUnselected }"}
+
+                %template{"v-if" => "line.isHeader"}
+                  %td.diff-line-num.header
+                  %td.line_content.header
+                    %strong {{line.richText}}
+                    %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
+
+                %template{"v-if" => "!line.isHeader"}
+                  %td.diff-line-num.old_line
+                    {{line.lineNumber}}
+                  %td.line_content
+                    {{{line.richText}}}
+
+    .files{"v-if" => "!isParallel"}
+      .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}
+        .file-title
+          %span {{file.new_path}}
+          .file-actions
+            %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
+
+        .diff-content.diff-wrap-lines
+          .diff-wrap-lines.code.file-content.js-syntax-highlight.white
+            %table
+              %tr.line_holder{"v-for" => "line in file.inlineLines", |
+                ":class" => "{ |
+                  'head': line.isHead, |
+                  'origin': line.isOrigin, |
+                  'match': line.hasMatch, |
+                  'selected': line.isSelected, |
+                  'unselected': line.isUnselected }"}
+
+                %template{"v-if" => "!line.isHeader"}
+                  %td.diff-line-num.new_line
+                    %a {{line.new_line}}
+                  %td.diff-line-num.old_line
+                    %a {{line.old_line}}
+                  %td.line_content
+                    {{{line.richText}}}
+
+                %template{"v-if" => "line.isHeader"}
+                  %td.diff-line-num.header
+                  %td.diff-line-num.header
+                  %td.line_content.header
+                    %strong {{{line.richText}}}
+                    %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
+
+    .content-block.oneline-block.files-changed
+      %strong.resolved-count {{resolvedCount}}
+      of
+      %strong.total-count {{conflictsCount}}
+      conflicts have been resolved
+
+      .commit-message-container.form-group
+        .max-width-marker
+        %textarea.form-control.js-commit-message{":disabled" => "!allResolved"} {{{conflictsData.commitMessage}}}
+
+      %button{type: 'button', class: 'btn btn-success js-submit-button', ":disabled" => "!allResolved"}
+        Commit conflict resolution
+
+      %button{type: 'button', class: 'btn btn-cancel'}
+        Cancel
diff --git a/app/views/projects/merge_requests/show/_conflicts.html.haml b/app/views/projects/merge_requests/show/_conflicts.html.haml
deleted file mode 100644
index 83be422ff35..00000000000
--- a/app/views/projects/merge_requests/show/_conflicts.html.haml
+++ /dev/null
@@ -1,103 +0,0 @@
-.loading{ "v-if" => "isLoading" }
-  %i.fa.fa-spinner.fa-spin
-
-.content-block.oneline-block.files-changed{ "v-if" => "!isLoading" }
-  .inline-parallel-buttons
-    .btn-group
-      %a.btn{ |
-        ":class" => "{'active': !isParallel}", |
-        "@click" => "handleViewTypeChange('inline')"}
-        Inline
-      %a.btn{ |
-        ":class" => "{'active': isParallel}", |
-        "@click" => "handleViewTypeChange('parallel')"}
-        Side-by-side
-
-  .js-toggle-container
-    .commit-stat-summary
-      Showing
-      %strong.cred {{conflictsCount}} conflicts
-      for
-      %strong {{conflictsData.source_branch}}
-      into
-      %strong {{conflictsData.target_branch}}
-
-.files-wrapper{ "v-if" => "!isLoading" }
-  .files{"v-if" => "isParallel"}
-    .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
-      .file-title
-        %span {{file.new_path}}
-        .file-actions
-          %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
-
-      .diff-content.diff-wrap-lines
-        .diff-wrap-lines.code.file-content.js-syntax-highlight.white
-          %table{"v-for" => "(key, group) in file.parallelLines"}
-            %tr.line_holder.parallel{"v-for" => "line in group", |
-              ":class" => "{ |
-                'head': line.isHead, |
-                'origin': line.isOrigin, |
-                'match': line.hasMatch, |
-                'selected': line.isSelected, |
-                'unselected': line.isUnselected }"}
-
-              %template{"v-if" => "line.isHeader"}
-                %td.diff-line-num.header
-                %td.line_content.header
-                  %strong {{line.richText}}
-                  %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
-
-              %template{"v-if" => "!line.isHeader"}
-                %td.diff-line-num.old_line
-                  {{line.lineNumber}}
-                %td.line_content
-                  {{{line.richText}}}
-
-  .files{"v-if" => "!isParallel"}
-    .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}
-      .file-title
-        %span {{file.new_path}}
-        .file-actions
-          %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
-
-      .diff-content.diff-wrap-lines
-        .diff-wrap-lines.code.file-content.js-syntax-highlight.white
-          %table
-            %tr.line_holder{"v-for" => "line in file.inlineLines", |
-              ":class" => "{ |
-                'head': line.isHead, |
-                'origin': line.isOrigin, |
-                'match': line.hasMatch, |
-                'selected': line.isSelected, |
-                'unselected': line.isUnselected }"}
-
-              %template{"v-if" => "!line.isHeader"}
-                %td.diff-line-num.new_line
-                  %a {{line.new_line}}
-                %td.diff-line-num.old_line
-                  %a {{line.old_line}}
-                %td.line_content
-                  {{{line.richText}}}
-
-              %template{"v-if" => "line.isHeader"}
-                %td.diff-line-num.header
-                %td.diff-line-num.header
-                %td.line_content.header
-                  %strong {{{line.richText}}}
-                  %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
-
-  .content-block.oneline-block.files-changed
-    %strong.resolved-count {{resolvedCount}}
-    of
-    %strong.total-count {{conflictsCount}}
-    conflicts have been resolved
-
-    .commit-message-container.form-group
-      .max-width-marker
-      %textarea.form-control.js-commit-message{":disabled" => "!allResolved"} {{{conflictsData.commitMessage}}}
-
-    %button{type: 'button', class: 'btn btn-success js-submit-button', ":disabled" => "!allResolved"}
-      Commit conflict resolution
-
-    %button{type: 'button', class: 'btn btn-cancel'}
-      Cancel

From 10cf933f70657eb0c413259319a103e15abd9f5c Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Mon, 1 Aug 2016 14:50:08 +0100
Subject: [PATCH 34/90] Highlight files based on merged file

---
 lib/gitlab/conflict/file.rb | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index bbabcf265f3..3d2b7272bad 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -59,8 +59,11 @@ module Gitlab
       end
 
       def highlight_lines!
-        their_highlight = Gitlab::Highlight.highlight_lines(repository, their_ref, their_path)
-        our_highlight = Gitlab::Highlight.highlight_lines(repository, our_ref, our_path)
+        their_file = lines.reject { |line| line.type == 'new' }.map(&:text).join("\n")
+        our_file = lines.reject { |line| line.type == 'old' }.map(&:text).join("\n")
+
+        their_highlight = Gitlab::Highlight.highlight(their_path, their_file, repository: repository).lines.map(&:html_safe)
+        our_highlight = Gitlab::Highlight.highlight(our_path, our_file, repository: repository).lines.map(&:html_safe)
 
         lines.each do |line|
           if line.type == 'old'

From f3cf40b8aaeb19479443821a767c354cd203c24e Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Mon, 1 Aug 2016 14:52:53 +0100
Subject: [PATCH 35/90] Handle case where one side deleted the file

---
 app/controllers/projects/merge_requests_controller.rb | 2 +-
 lib/gitlab/conflict/file_collection.rb                | 8 +++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index e34f4d102ce..13eb5fb2ffb 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -140,7 +140,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
       format.json do
         begin
           render json: Gitlab::Conflict::FileCollection.new(@merge_request)
-        rescue Gitlab::Conflict::Parser::ParserError => e
+        rescue Gitlab::Conflict::Parser::ParserError, Gitlab::Conflict::FileCollection::ConflictSideMissing => e
           render json: { message: 'Unable to resolve conflicts in the web interface for this merge request' }
         end
       end
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index e621a76a7de..5122a5b2111 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -1,6 +1,9 @@
 module Gitlab
   module Conflict
     class FileCollection
+      class ConflictSideMissing < StandardError
+      end
+
       attr_reader :merge_request, :our_commit, :their_commit
 
       def initialize(merge_request)
@@ -39,10 +42,9 @@ module Gitlab
 
       def files
         @files ||= merge_index.conflicts.map do |conflict|
-          their_path = conflict[:theirs][:path]
-          our_path = conflict[:ours][:path]
+          raise ConflictSideMissing unless conflict[:theirs] && conflict[:ours]
 
-          Gitlab::Conflict::File.new(merge_index.merge_file(our_path),
+          Gitlab::Conflict::File.new(merge_index.merge_file(conflict[:ours][:path]),
                                      conflict,
                                      diff_refs: merge_request.diff_refs,
                                      repository: repository)

From 6f3501fe252404b342984514b1b784ffa73edbd0 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Mon, 1 Aug 2016 15:41:49 +0100
Subject: [PATCH 36/90] Fix match line headers at start / end of file

---
 lib/gitlab/conflict/file.rb | 49 +++++++++++++++++++++++++------------
 1 file changed, 33 insertions(+), 16 deletions(-)

diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 3d2b7272bad..2c7f6628c23 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -77,6 +77,10 @@ module Gitlab
       def sections
         return @sections if @sections
 
+        candidate_match_headers = lines.map do |line|
+          " #{line.text}" if line.text.match(/\A[A-Za-z$_]/) && line.type.nil?
+        end
+
         chunked_lines = lines.chunk { |line| line.type.nil? }
         last_candidate_match_header = nil
         match_line_header = nil
@@ -85,40 +89,41 @@ module Gitlab
         @sections = chunked_lines.flat_map.with_index do |(no_conflict, lines), i|
           section = nil
 
-          lines.each do |line|
-            last_candidate_match_header = " #{line.text}" if line.text.match(/\A[A-Za-z$_]/)
-          end
-
           if no_conflict
             conflict_before = i > 0
             conflict_after = chunked_lines.peek
 
             if conflict_before && conflict_after
               if lines.length > CONTEXT_LINES * 2
+                head_lines = lines.first(CONTEXT_LINES)
                 tail_lines = lines.last(CONTEXT_LINES)
-                first_tail_line = tail_lines.first
-                match_line_header = last_candidate_match_header
-                match_line = Gitlab::Diff::Line.new('',
-                                                    'match',
-                                                    first_tail_line.index,
-                                                    first_tail_line.old_pos,
-                                                    first_tail_line.new_pos)
+
+                update_match_line_text(match_line, head_lines.last, candidate_match_headers)
+
+                match_line = create_match_line(tail_lines.first)
+                update_match_line_text(match_line, tail_lines.last, candidate_match_headers)
 
                 section = [
-                  { conflict: false, lines: lines.first(CONTEXT_LINES) },
+                  { conflict: false, lines: head_lines },
                   { conflict: false, lines: tail_lines.unshift(match_line) }
                 ]
               end
             elsif conflict_after
-              lines = lines.last(CONTEXT_LINES)
+              tail_lines = lines.last(CONTEXT_LINES)
+
+              if lines.length > CONTEXT_LINES
+                match_line = create_match_line(tail_lines.first)
+
+                tail_lines.unshift(match_line)
+              end
+
+              lines = tail_lines
             elsif conflict_before
               lines = lines.first(CONTEXT_LINES)
             end
           end
 
-          if match_line && !section
-            match_line.text = "@@ -#{match_line.old_pos},#{lines.last.old_pos} +#{match_line.new_pos},#{lines.last.new_pos} @@#{match_line_header}"
-          end
+          update_match_line_text(match_line, lines.last, candidate_match_headers) unless section
 
           section ||= { conflict: !no_conflict, lines: lines }
           section[:id] = line_code(lines.first) unless no_conflict
@@ -130,6 +135,18 @@ module Gitlab
         Gitlab::Diff::LineCode.generate(our_path, line.new_pos, line.old_pos)
       end
 
+      def create_match_line(line)
+        Gitlab::Diff::Line.new('', 'match', line.index, line.old_pos, line.new_pos)
+      end
+
+      def update_match_line_text(match_line, line, headers)
+        return unless match_line
+
+        header = headers.first(line.index).compact.last
+
+        match_line.text = "@@ -#{match_line.old_pos},#{line.old_pos} +#{match_line.new_pos},#{line.new_pos} @@#{header}"
+      end
+
       def as_json(opts = nil)
         {
           old_path: their_path,

From 261d47bce9d7cc80b4c2068cb612411fe51530ee Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Tue, 2 Aug 2016 09:20:22 +0100
Subject: [PATCH 37/90] Fix specs

- Add match line header to expected result for `File#sections`.
- Lowercase CSS colours.
- Remove unused `diff_refs` keyword argument.
- Rename `parent` -> `parent_file`, to be more explicit.
- Skip an iteration when highlighting.
---
 .../stylesheets/pages/merge_conflicts.scss    | 20 +++++++++----------
 lib/gitlab/conflict/file.rb                   | 18 +++++++----------
 lib/gitlab/conflict/file_collection.rb        |  1 -
 lib/gitlab/conflict/parser.rb                 |  6 +++---
 lib/gitlab/diff/line.rb                       |  6 +++---
 spec/lib/gitlab/conflict/file_spec.rb         |  5 ++---
 6 files changed, 25 insertions(+), 31 deletions(-)

diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index 0e306c26541..fe81ce2eb67 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -1,15 +1,15 @@
-$head_line:               #EFFDEB;
-$head_gutter:             #DAFACE;
-$selected_head_gutter:    #B2EE9E;
-$selected_head_line:      #D4F5C9;
+$head_line:               #effdeb;
+$head_gutter:             #daface;
+$selected_head_gutter:    #b2ee9e;
+$selected_head_line:      #d4f5c9;
 
-$origin_line:             #F2F9FF;
-$origin_gutter:           #E0F0FF;
-$selected_origin_gutter:  #A3D3FF;
-$selected_origin_line:    #CEE4F9;
+$origin_line:             #f2f9ff;
+$origin_gutter:           #e0f0ff;
+$selected_origin_gutter:  #a3d3ff;
+$selected_origin_line:    #cee4f9;
 
-$unselected_gutter:       #EEEEEE;
-$unselected_line:         #F8F8F8;
+$unselected_gutter:       #eeeeee;
+$unselected_line:         #f8f8f8;
 
 
 #conflicts {
diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 2c7f6628c23..7f10b8ea8fd 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -6,14 +6,12 @@ module Gitlab
 
       CONTEXT_LINES = 3
 
-      attr_reader :merge_file_result, :their_path, :their_ref, :our_path, :our_ref, :repository
+      attr_reader :merge_file_result, :their_path, :our_path, :repository
 
-      def initialize(merge_file_result, conflict, diff_refs:, repository:)
+      def initialize(merge_file_result, conflict, repository:)
         @merge_file_result = merge_file_result
         @their_path = conflict[:theirs][:path]
         @our_path = conflict[:ours][:path]
-        @their_ref = diff_refs.start_sha
-        @our_ref = diff_refs.head_sha
         @repository = repository
       end
 
@@ -22,7 +20,7 @@ module Gitlab
         @lines ||= Gitlab::Conflict::Parser.new.parse(merge_file_result[:data],
                                                       our_path: our_path,
                                                       their_path: their_path,
-                                                      parent: self)
+                                                      parent_file: self)
       end
 
       def resolve!(resolution, index:, rugged:)
@@ -62,14 +60,14 @@ module Gitlab
         their_file = lines.reject { |line| line.type == 'new' }.map(&:text).join("\n")
         our_file = lines.reject { |line| line.type == 'old' }.map(&:text).join("\n")
 
-        their_highlight = Gitlab::Highlight.highlight(their_path, their_file, repository: repository).lines.map(&:html_safe)
-        our_highlight = Gitlab::Highlight.highlight(our_path, our_file, repository: repository).lines.map(&:html_safe)
+        their_highlight = Gitlab::Highlight.highlight(their_path, their_file, repository: repository).lines
+        our_highlight = Gitlab::Highlight.highlight(our_path, our_file, repository: repository).lines
 
         lines.each do |line|
           if line.type == 'old'
-            line.rich_text = their_highlight[line.old_line - 1]
+            line.rich_text = their_highlight[line.old_line - 1].html_safe
           else
-            line.rich_text = our_highlight[line.new_line - 1]
+            line.rich_text = our_highlight[line.new_line - 1].html_safe
           end
         end
       end
@@ -82,8 +80,6 @@ module Gitlab
         end
 
         chunked_lines = lines.chunk { |line| line.type.nil? }
-        last_candidate_match_header = nil
-        match_line_header = nil
         match_line = nil
 
         @sections = chunked_lines.flat_map.with_index do |(no_conflict, lines), i|
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index 5122a5b2111..da9994a7405 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -46,7 +46,6 @@ module Gitlab
 
           Gitlab::Conflict::File.new(merge_index.merge_file(conflict[:ours][:path]),
                                      conflict,
-                                     diff_refs: merge_request.diff_refs,
                                      repository: repository)
         end
       end
diff --git a/lib/gitlab/conflict/parser.rb b/lib/gitlab/conflict/parser.rb
index 9f27cba353a..6eccded7872 100644
--- a/lib/gitlab/conflict/parser.rb
+++ b/lib/gitlab/conflict/parser.rb
@@ -13,7 +13,7 @@ module Gitlab
       class UnmergeableFile < ParserError
       end
 
-      def parse(text, our_path:, their_path:, parent: nil)
+      def parse(text, our_path:, their_path:, parent_file: nil)
         raise UnmergeableFile if text.blank? # Typically a binary file
         raise UnmergeableFile if text.length > 102400
 
@@ -43,9 +43,9 @@ module Gitlab
             type = nil
           elsif line[0] == '\\'
             type = 'nonewline'
-            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new, parent: parent)
+            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new, parent_file: parent_file)
           else
-            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new, parent: parent)
+            lines << Gitlab::Diff::Line.new(full_line, type, line_obj_index, line_old, line_new, parent_file: parent_file)
             line_old += 1 if type != 'new'
             line_new += 1 if type != 'old'
 
diff --git a/lib/gitlab/diff/line.rb b/lib/gitlab/diff/line.rb
index 38400b48b5c..80a146b4a5a 100644
--- a/lib/gitlab/diff/line.rb
+++ b/lib/gitlab/diff/line.rb
@@ -5,10 +5,10 @@ module Gitlab
       attr_writer :rich_text
       attr_accessor :text
 
-      def initialize(text, type, index, old_pos, new_pos, parent: nil)
+      def initialize(text, type, index, old_pos, new_pos, parent_file: nil)
         @text, @type, @index = text, type, index
         @old_pos, @new_pos = old_pos, new_pos
-        @parent = parent
+        @parent_file = parent_file
       end
 
       def self.init_from_hash(hash)
@@ -46,7 +46,7 @@ module Gitlab
       end
 
       def rich_text
-        @parent.highlight_lines! if @parent && !@rich_text
+        @parent_file.highlight_lines! if @parent_file && !@rich_text
 
         @rich_text
       end
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index 735b5b34623..dd3ddc70cf7 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -5,12 +5,11 @@ describe Gitlab::Conflict::File, lib: true do
   let(:repository) { project.repository }
   let(:rugged) { repository.rugged }
   let(:their_commit) { rugged.branches['conflict-a'].target }
-  let(:diff_refs) { Gitlab::Diff::DiffRefs.new(base_sha: their_commit.oid, head_sha: our_commit.oid) }
   let(:our_commit) { rugged.branches['conflict-b'].target }
   let(:index) { rugged.merge_commits(our_commit, their_commit) }
   let(:conflict) { index.conflicts.last }
   let(:merge_file_result) { index.merge_file('files/ruby/regex.rb') }
-  let(:conflict_file) { Gitlab::Conflict::File.new(merge_file_result, conflict, diff_refs: diff_refs, repository: repository) }
+  let(:conflict_file) { Gitlab::Conflict::File.new(merge_file_result, conflict, repository: repository) }
 
   describe '#resolve_lines' do
     let(:section_keys) { conflict_file.sections.map { |section| section[:id] }.compact }
@@ -92,7 +91,7 @@ describe Gitlab::Conflict::File, lib: true do
 
       expect(section[:conflict]).to be_falsey
       expect(match_line.type).to eq('match')
-      expect(match_line.text).to eq('@@ -46,53 +46,53 @@')
+      expect(match_line.text).to eq('@@ -46,53 +46,53 @@ module Gitlab')
     end
 
     it 'does not return match lines when there is no gap between sections' do

From c2295fbdf8cfd348dfcee04f63c9c9d49646beb3 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Tue, 2 Aug 2016 14:51:43 +0300
Subject: [PATCH 38/90] Render right sidebar and handle request error.

---
 .../merge_conflict_data_provider.js.es6       | 26 ++++++++++++++-----
 .../merge_conflict_resolver.js.es6            | 16 +++++++++---
 .../projects/merge_requests_controller.rb     |  5 +++-
 .../{conflicts.haml => conflicts.html.haml}   | 13 +++++++---
 4 files changed, 45 insertions(+), 15 deletions(-)
 rename app/views/projects/merge_requests/{conflicts.haml => conflicts.html.haml} (91%)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index b1f1e7bd78c..05ffc470d3e 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -8,6 +8,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
     return {
       isLoading      : true,
+      hasError       : false,
       isParallel     : diffViewType === 'parallel',
       diffViewType   : diffViewType,
       conflictsData  : {},
@@ -18,12 +19,19 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
   decorateData(vueInstance, data) {
     this.vueInstance    = vueInstance;
-    data.shortCommitSha = data.commit_sha.slice(0, 7);
-    data.commitMesage   = data.commit_message;
 
-    this.setParallelLines(data);
-    this.setInlineLines(data);
-    this.updateResolutionsData(data);
+    if (data.type === 'error') {
+      vueInstance.hasError = true;
+      data.errorMessage = data.message;
+    }
+    else {
+      data.shortCommitSha = data.commit_sha.slice(0, 7);
+      data.commitMesage   = data.commit_message;
+
+      this.setParallelLines(data);
+      this.setInlineLines(data);
+      this.updateResolutionsData(data);
+    }
 
     vueInstance.conflictsData = data;
   }
@@ -166,7 +174,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
     vi.diffView   = newType;
     vi.isParallel = newType === 'parallel';
     $.cookie('diff_view', newType); // TODO: Make sure that cookie path added.
-    $('.container-fluid').toggleClass('container-limited');
+    $('.content-wrapper .container-fluid').toggleClass('container-limited');
   }
 
 
@@ -270,4 +278,10 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
     }
   }
 
+
+  handleFailedRequest(vueInstance, data) {
+    vueInstance.hasError = true;
+    vueInstance.conflictsData.errorMessage = 'Something went wrong!';
+  }
+
 }
diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index 76298150767..8da698b3b3e 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -29,10 +29,18 @@ window.MergeConflictResolver = class MergeConflictResolver {
 
 
   fetchData() {
-    $.get('./conflicts.json').done( (data) => {
-      this.dataProvider.decorateData(this.vue, data);
-      this.vue.isLoading = false;
-    })
+    const dp = this.dataProvider;
+
+    $.get('./conflicts.json')
+      .done( (data) => {
+        dp.decorateData(this.vue, data);
+      })
+      .error( (data) => {
+        dp.handleFailedRequest(this.vue, data);
+      })
+      .always( () => {
+        this.vue.isLoading = false;
+      })
   }
 
 
diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 13eb5fb2ffb..2f934729432 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -141,7 +141,10 @@ class Projects::MergeRequestsController < Projects::ApplicationController
         begin
           render json: Gitlab::Conflict::FileCollection.new(@merge_request)
         rescue Gitlab::Conflict::Parser::ParserError, Gitlab::Conflict::FileCollection::ConflictSideMissing => e
-          render json: { message: 'Unable to resolve conflicts in the web interface for this merge request' }
+          render json: {
+            message: 'Unable to resolve conflicts in the web interface for this merge request',
+            type: 'error'
+          }
         end
       end
     end
diff --git a/app/views/projects/merge_requests/conflicts.haml b/app/views/projects/merge_requests/conflicts.html.haml
similarity index 91%
rename from app/views/projects/merge_requests/conflicts.haml
rename to app/views/projects/merge_requests/conflicts.html.haml
index a34a58baad6..b60e5558e7f 100644
--- a/app/views/projects/merge_requests/conflicts.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -2,14 +2,19 @@
 
 = render "projects/merge_requests/show/mr_title"
 
-.merge-request-details.issuable-details{data: {id: @merge_request.project.id}}
+.merge-request-details.issuable-details
   = render "projects/merge_requests/show/mr_box"
 
+= render 'shared/issuable/sidebar', issuable: @merge_request
+
 #conflicts
-  .loading{ "v-if" => "isLoading" }
+  .loading{"v-if" => "isLoading"}
     %i.fa.fa-spinner.fa-spin
 
-  .content-block.oneline-block.files-changed{ "v-if" => "!isLoading" }
+  .content-block.oneline-block{"v-if" => "hasError"}
+    %p {{conflictsData.errorMessage}}
+
+  .content-block.oneline-block.files-changed{"v-if" => "!isLoading && !hasError"}
     .inline-parallel-buttons
       .btn-group
         %a.btn{ |
@@ -30,7 +35,7 @@
         into
         %strong {{conflictsData.target_branch}}
 
-  .files-wrapper{ "v-if" => "!isLoading" }
+  .files-wrapper{"v-if" => "!isLoading && !hasError"}
     .files{"v-if" => "isParallel"}
       .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
         .file-title

From 8b6a075e6ff3197ee984c3d21395e1e26bc3bb15 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Tue, 2 Aug 2016 15:16:21 +0300
Subject: [PATCH 39/90] Implement commit in merge conflicts UI.

---
 .../javascripts/merge_conflict_data_provider.js.es6    | 10 +++++++++-
 app/assets/javascripts/merge_conflict_resolver.js.es6  | 10 ++++++++++
 app/assets/javascripts/merge_request_tabs.js           |  2 +-
 app/views/projects/merge_requests/conflicts.html.haml  |  9 +++++----
 4 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 05ffc470d3e..00c52794f51 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -26,7 +26,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
     }
     else {
       data.shortCommitSha = data.commit_sha.slice(0, 7);
-      data.commitMesage   = data.commit_message;
+      data.commitMessage  = data.commit_message;
 
       this.setParallelLines(data);
       this.setInlineLines(data);
@@ -284,4 +284,12 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
     vueInstance.conflictsData.errorMessage = 'Something went wrong!';
   }
 
+
+  getCommitData() {
+    return {
+      commitMessage: this.vueInstance.conflictsData.commitMessage,
+      sections: this.vueInstance.resolutionData
+    }
+  }
+
 }
diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index 8da698b3b3e..6da5bf6568e 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -22,6 +22,9 @@ window.MergeConflictResolver = class MergeConflictResolver {
         },
         handleViewTypeChange(newType) {
           that.dataProvider.updateViewType(newType);
+        },
+        commit() {
+          that.commit();
         }
       }
     })
@@ -54,4 +57,11 @@ window.MergeConflictResolver = class MergeConflictResolver {
     }
   }
 
+  commit() {
+    $.post('./resolve_conflicts', this.dataProvider.getCommitData())
+      .always( (data) => {
+        console.log(data)
+      })
+  }
+
 }
diff --git a/app/assets/javascripts/merge_request_tabs.js b/app/assets/javascripts/merge_request_tabs.js
index e038abe378c..52c2ed61012 100644
--- a/app/assets/javascripts/merge_request_tabs.js
+++ b/app/assets/javascripts/merge_request_tabs.js
@@ -81,7 +81,7 @@
       if (action === 'show') {
         action = 'notes';
       }
-      new_state = this._location.pathname.replace(/\/(commits|diffs|builds|conflicts)(\.html)?\/?$/, '');
+      new_state = this._location.pathname.replace(/\/(commits|diffs|builds)(\.html)?\/?$/, '');
       if (action !== 'notes') {
         new_state += "/" + action;
       }
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index b60e5558e7f..b178d7d2da1 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -107,10 +107,11 @@
 
       .commit-message-container.form-group
         .max-width-marker
-        %textarea.form-control.js-commit-message{":disabled" => "!allResolved"} {{{conflictsData.commitMessage}}}
+        %textarea.form-control.js-commit-message{":disabled" => "!allResolved", "v-model" => "conflictsData.commitMessage"}
+          {{{conflictsData.commitMessage}}}
 
-      %button{type: 'button', class: 'btn btn-success js-submit-button', ":disabled" => "!allResolved"}
+      %button{type: 'button', class: 'btn btn-success js-submit-button', ":disabled" => "!allResolved", "@click" => "commit()"}
         Commit conflict resolution
 
-      %button{type: 'button', class: 'btn btn-cancel'}
-        Cancel
+      / %button{type: 'button', class: 'btn btn-cancel'}
+      /   Cancel

From 76cd67b0052ddf68ece6edef174755d0e3b4aa8a Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Tue, 2 Aug 2016 13:23:55 +0100
Subject: [PATCH 40/90] Make SCSS lint and RuboCop happy

---
 app/assets/stylesheets/pages/merge_conflicts.scss     | 6 +++---
 app/controllers/projects/merge_requests_controller.rb | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index fe81ce2eb67..a0309113054 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -8,7 +8,7 @@ $origin_gutter:           #e0f0ff;
 $selected_origin_gutter:  #a3d3ff;
 $selected_origin_line:    #cee4f9;
 
-$unselected_gutter:       #eeeeee;
+$unselected_gutter:       #eee;
 $unselected_line:         #f8f8f8;
 
 
@@ -93,8 +93,8 @@ $unselected_line:         #f8f8f8;
 
     button {
       border-radius: 4px;
-      border: 1px solid #E1E1E1;
-      background: #FFF;
+      border: 1px solid #e1e1e1;
+      background: #fff;
       font-size: 10px;
       position: absolute;
       right: 20px;
diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 2f934729432..abea9ced624 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -140,7 +140,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
       format.json do
         begin
           render json: Gitlab::Conflict::FileCollection.new(@merge_request)
-        rescue Gitlab::Conflict::Parser::ParserError, Gitlab::Conflict::FileCollection::ConflictSideMissing => e
+        rescue Gitlab::Conflict::Parser::ParserError, Gitlab::Conflict::FileCollection::ConflictSideMissing
           render json: {
             message: 'Unable to resolve conflicts in the web interface for this merge request',
             type: 'error'

From 3b84cfdc74e27c5f0b94187f5a15c95e3f292554 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Tue, 2 Aug 2016 13:56:50 +0100
Subject: [PATCH 41/90] Use same resolution format on FE and BE

---
 .../merge_conflict_data_provider.js.es6       |  2 +-
 lib/gitlab/conflict/file.rb                   |  4 ++--
 lib/gitlab/conflict/file_collection.rb        |  5 ++--
 .../merge_requests_controller_spec.rb         | 23 ++++++++++---------
 spec/lib/gitlab/conflict/file_spec.rb         |  4 ++--
 5 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 00c52794f51..c0a3ecc6df3 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -287,7 +287,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
   getCommitData() {
     return {
-      commitMessage: this.vueInstance.conflictsData.commitMessage,
+      commit_message: this.vueInstance.conflictsData.commitMessage,
       sections: this.vueInstance.resolutionData
     }
   }
diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 7f10b8ea8fd..b6fa9402d46 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -44,9 +44,9 @@ module Gitlab
           section_id ||= line_code(line)
 
           case resolution[section_id]
-          when 'ours'
+          when 'head'
             next unless line.type == 'new'
-          when 'theirs'
+          when 'origin'
             next unless line.type == 'old'
           else
             raise MissingResolution, "Missing resolution for section ID: #{section_id}"
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index da9994a7405..5df54fd8677 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -20,10 +20,11 @@ module Gitlab
         @merge_index ||= repository.rugged.merge_commits(our_commit, their_commit)
       end
 
-      def resolve_conflicts!(resolutions, commit_message, user:)
+      def resolve_conflicts!(params, user:)
+        resolutions = params[:sections]
+        commit_message = params[:commit_message] || default_commit_message
         rugged = repository.rugged
         committer = repository.user_to_committer(user)
-        commit_message ||= default_commit_message
 
         files.each do |file|
           file.resolve!(resolutions, index: merge_index, rugged: rugged)
diff --git a/spec/controllers/projects/merge_requests_controller_spec.rb b/spec/controllers/projects/merge_requests_controller_spec.rb
index 226650399cc..7d1028c11bf 100644
--- a/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -549,7 +549,7 @@ describe Projects::MergeRequestsController do
       end
 
       it 'returns JSON with a message' do
-        expect(json_response.keys).to contain_exactly('message')
+        expect(json_response.keys).to contain_exactly('message', 'type')
       end
     end
 
@@ -613,30 +613,31 @@ describe Projects::MergeRequestsController do
     let(:json_response) { JSON.parse(response.body) }
     let!(:original_head_sha) { merge_request_with_conflicts.diff_head_sha }
 
-    def resolve_conflicts(params)
+    def resolve_conflicts(sections)
       post :resolve_conflicts,
            namespace_id: merge_request_with_conflicts.project.namespace.to_param,
            project_id: merge_request_with_conflicts.project.to_param,
            id: merge_request_with_conflicts.iid,
            format: 'json',
-           merge_request: params
+           sections: sections,
+           commit_message: 'Commit message'
     end
 
     context 'with valid params' do
       before do
-        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_4_4' => 'ours',
-                          '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_9_9' => 'ours',
-                          '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_21_21' => 'theirs',
-                          '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_49_49' => 'theirs')
+        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_4_4' => 'head',
+                          '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_9_9' => 'head',
+                          '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_21_21' => 'origin',
+                          '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_49_49' => 'origin')
       end
 
       it 'creates a new commit on the branch' do
         expect(original_head_sha).not_to eq(merge_request_with_conflicts.source_branch_head.sha)
-        expect(merge_request_with_conflicts.source_branch_head.message).to include('Merge branch')
+        expect(merge_request_with_conflicts.source_branch_head.message).to include('Commit message')
       end
 
-      it 'redirects to the MR show page' do
-        expect(response).to redirect_to([merge_request_with_conflicts.target_project.namespace.becomes(Namespace), merge_request_with_conflicts.target_project, merge_request_with_conflicts])
+      it 'returns an OK resposne' do
+        expect(response).to have_http_status(:ok)
       end
 
       context 'undoing the resolution' do
@@ -655,7 +656,7 @@ describe Projects::MergeRequestsController do
 
     context 'when sections are missing' do
       before do
-        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_4_4' => 'ours')
+        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_4_4' => 'head')
       end
 
       it 'returns a 400 error' do
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index dd3ddc70cf7..290640ced49 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -15,7 +15,7 @@ describe Gitlab::Conflict::File, lib: true do
     let(:section_keys) { conflict_file.sections.map { |section| section[:id] }.compact }
 
     context 'when resolving everything to the same side' do
-      let(:resolution_hash) { section_keys.map { |key| [key, 'ours'] }.to_h }
+      let(:resolution_hash) { section_keys.map { |key| [key, 'head'] }.to_h }
       let(:resolved_lines) { conflict_file.resolve_lines(resolution_hash) }
       let(:expected_lines) { conflict_file.lines.reject { |line| line.type == 'old' } }
 
@@ -30,7 +30,7 @@ describe Gitlab::Conflict::File, lib: true do
 
     context 'with mixed resolutions' do
       let(:resolution_hash) do
-        section_keys.map.with_index { |key, i| [key, i.even? ? 'ours' : 'theirs'] }.to_h
+        section_keys.map.with_index { |key, i| [key, i.even? ? 'head' : 'origin'] }.to_h
       end
 
       let(:resolved_lines) { conflict_file.resolve_lines(resolution_hash) }

From 3cc07e7e391a995361bb2523fef5e092570643f3 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Tue, 2 Aug 2016 14:04:16 +0100
Subject: [PATCH 42/90] Fix resolve_conflicts endpoint

---
 app/controllers/projects/merge_requests_controller.rb | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index abea9ced624..42dc0bb4a43 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -152,10 +152,9 @@ class Projects::MergeRequestsController < Projects::ApplicationController
 
   def resolve_conflicts
     begin
-      Gitlab::Conflict::FileCollection.new(@merge_request).resolve_conflicts!(params[:merge_request], nil, user: current_user)
+      Gitlab::Conflict::FileCollection.new(@merge_request).resolve_conflicts!(params, user: current_user)
 
-      redirect_to namespace_project_merge_request_path(@project.namespace, @project, @merge_request),
-                  notice: 'Merge conflicts resolved. The merge request can now be merged.'
+      head :ok
     rescue Gitlab::Conflict::File::MissingResolution => e
       render status: :bad_request, json: { message: e.message }
     end

From e50e88b85c54097db22d571cfc76fcef143e1d01 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Wed, 3 Aug 2016 12:02:20 +0100
Subject: [PATCH 43/90] Add blob_path to conflict file JSON

---
 lib/gitlab/conflict/file.rb            | 12 +++++++++---
 lib/gitlab/conflict/file_collection.rb |  2 +-
 spec/lib/gitlab/conflict/file_spec.rb  | 10 +++++++++-
 3 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index b6fa9402d46..16727e752bd 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -1,18 +1,21 @@
 module Gitlab
   module Conflict
     class File
+      include Gitlab::Routing.url_helpers
+
       class MissingResolution < StandardError
       end
 
       CONTEXT_LINES = 3
 
-      attr_reader :merge_file_result, :their_path, :our_path, :repository
+      attr_reader :merge_file_result, :their_path, :our_path, :merge_request, :repository
 
-      def initialize(merge_file_result, conflict, repository:)
+      def initialize(merge_file_result, conflict, merge_request:)
         @merge_file_result = merge_file_result
         @their_path = conflict[:theirs][:path]
         @our_path = conflict[:ours][:path]
-        @repository = repository
+        @merge_request = merge_request
+        @repository = merge_request.project.repository
       end
 
       # Array of Gitlab::Diff::Line objects
@@ -147,6 +150,9 @@ module Gitlab
         {
           old_path: their_path,
           new_path: our_path,
+          blob_path: namespace_project_blob_path(merge_request.project.namespace,
+                                                 merge_request.project,
+                                                 ::File.join(merge_request.diff_refs.head_sha, our_path)),
           sections: sections
         }
       end
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index 5df54fd8677..04a75f9edc3 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -47,7 +47,7 @@ module Gitlab
 
           Gitlab::Conflict::File.new(merge_index.merge_file(conflict[:ours][:path]),
                                      conflict,
-                                     repository: repository)
+                                     merge_request: merge_request)
         end
       end
 
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index 290640ced49..a57ca70672b 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -6,10 +6,11 @@ describe Gitlab::Conflict::File, lib: true do
   let(:rugged) { repository.rugged }
   let(:their_commit) { rugged.branches['conflict-a'].target }
   let(:our_commit) { rugged.branches['conflict-b'].target }
+  let(:merge_request) { create(:merge_request, source_branch: 'conflict-b', target_branch: 'conflict-a', source_project: project) }
   let(:index) { rugged.merge_commits(our_commit, their_commit) }
   let(:conflict) { index.conflicts.last }
   let(:merge_file_result) { index.merge_file('files/ruby/regex.rb') }
-  let(:conflict_file) { Gitlab::Conflict::File.new(merge_file_result, conflict, repository: repository) }
+  let(:conflict_file) { Gitlab::Conflict::File.new(merge_file_result, conflict, merge_request: merge_request) }
 
   describe '#resolve_lines' do
     let(:section_keys) { conflict_file.sections.map { |section| section[:id] }.compact }
@@ -141,4 +142,11 @@ describe Gitlab::Conflict::File, lib: true do
       expect(section_ids.uniq).to eq(section_ids)
     end
   end
+
+  describe '#as_json' do
+    it 'includes the blob path for the file' do
+      expect(conflict_file.as_json[:blob_path]).
+        to eq("/#{project.namespace.to_param}/#{merge_request.project.to_param}/blob/#{our_commit.oid}/files/ruby/regex.rb")
+    end
+  end
 end

From 52eb523c9b28a258489202dd35a2a65535d31cab Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Wed, 3 Aug 2016 12:10:42 +0100
Subject: [PATCH 44/90] Add blob_icon to conflict file JSON

---
 lib/gitlab/conflict/file.rb           | 6 ++++--
 spec/lib/gitlab/conflict/file_spec.rb | 4 ++++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 16727e752bd..1d63aec6903 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -2,18 +2,20 @@ module Gitlab
   module Conflict
     class File
       include Gitlab::Routing.url_helpers
+      include IconsHelper
 
       class MissingResolution < StandardError
       end
 
       CONTEXT_LINES = 3
 
-      attr_reader :merge_file_result, :their_path, :our_path, :merge_request, :repository
+      attr_reader :merge_file_result, :their_path, :our_path, :our_mode, :merge_request, :repository
 
       def initialize(merge_file_result, conflict, merge_request:)
         @merge_file_result = merge_file_result
         @their_path = conflict[:theirs][:path]
         @our_path = conflict[:ours][:path]
+        @our_mode = conflict[:ours][:mode]
         @merge_request = merge_request
         @repository = merge_request.project.repository
       end
@@ -30,7 +32,6 @@ module Gitlab
         new_file = resolve_lines(resolution).map(&:text).join("\n")
 
         oid = rugged.write(new_file, :blob)
-        our_mode = index.conflict_get(our_path)[:ours][:mode]
         index.add(path: our_path, oid: oid, mode: our_mode)
         index.conflict_remove(our_path)
       end
@@ -150,6 +151,7 @@ module Gitlab
         {
           old_path: their_path,
           new_path: our_path,
+          blob_icon: file_type_icon_class('file', our_mode, our_path),
           blob_path: namespace_project_blob_path(merge_request.project.namespace,
                                                  merge_request.project,
                                                  ::File.join(merge_request.diff_refs.head_sha, our_path)),
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index a57ca70672b..cf670b3182a 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -148,5 +148,9 @@ describe Gitlab::Conflict::File, lib: true do
       expect(conflict_file.as_json[:blob_path]).
         to eq("/#{project.namespace.to_param}/#{merge_request.project.to_param}/blob/#{our_commit.oid}/files/ruby/regex.rb")
     end
+
+    it 'includes the blob icon for the file' do
+      expect(conflict_file.as_json[:blob_icon]).to eq('file-text-o')
+    end
   end
 end

From 29bed9967bdef0b133d35065dba7bfb1ec36c5b3 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Tue, 2 Aug 2016 23:10:18 +0300
Subject: [PATCH 45/90] Add v-cloak to parent Vue element for MCUI.

---
 app/views/projects/merge_requests/conflicts.html.haml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index b178d7d2da1..129b4c04a25 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -7,7 +7,7 @@
 
 = render 'shared/issuable/sidebar', issuable: @merge_request
 
-#conflicts
+#conflicts{"v-cloak" => "true"}
   .loading{"v-if" => "isLoading"}
     %i.fa.fa-spinner.fa-spin
 

From e47e537b0716ede45e741d0b726621c120472e4a Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Tue, 2 Aug 2016 23:27:37 +0300
Subject: [PATCH 46/90] Handle renamed files in file header.

---
 .../javascripts/merge_conflict_data_provider.js.es6       | 8 ++++++++
 app/views/projects/merge_requests/conflicts.html.haml     | 5 +++--
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index c0a3ecc6df3..2b84d9b694d 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -52,6 +52,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
   setParallelLines(data) {
     data.files.forEach( (file) => {
+      file.filePath = this.getFilePath(file);
       file.parallelLines = { left: [], right: [] };
 
       file.sections.forEach( (section) => {
@@ -110,6 +111,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
   setInlineLines(data) {
     data.files.forEach( (file) => {
       file.inlineLines = []
+      file.filePath = this.getFilePath(file);
 
       file.sections.forEach( (section) => {
         let currentLineType = 'new';
@@ -292,4 +294,10 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
     }
   }
 
+
+  getFilePath(file) {
+    const { old_path, new_path } = file;
+    return old_path === new_path ? new_path : `${old_path} &rarr; ${new_path}`;
+  }
+
 }
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index 129b4c04a25..b2531fc5073 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -39,7 +39,7 @@
     .files{"v-if" => "isParallel"}
       .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
         .file-title
-          %span {{file.new_path}}
+          %span {{{file.filePath}}}
           .file-actions
             %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
 
@@ -66,10 +66,11 @@
                   %td.line_content
                     {{{line.richText}}}
 
+
     .files{"v-if" => "!isParallel"}
       .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}
         .file-title
-          %span {{file.new_path}}
+          %span {{{file.filePath}}}
           .file-actions
             %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
 

From 16b13cbc2c47c3a8d867ef345d36371856b8c289 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Wed, 3 Aug 2016 12:56:16 +0300
Subject: [PATCH 47/90] Put file blob link as href.

---
 app/views/projects/merge_requests/conflicts.html.haml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index b2531fc5073..b24bd412815 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -41,7 +41,8 @@
         .file-title
           %span {{{file.filePath}}}
           .file-actions
-            %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
+            %a.btn.view-file.btn-file-option{":href" => "file.blobLink"}
+              View file @{{conflictsData.shortCommitSha}}
 
         .diff-content.diff-wrap-lines
           .diff-wrap-lines.code.file-content.js-syntax-highlight.white
@@ -72,7 +73,8 @@
         .file-title
           %span {{{file.filePath}}}
           .file-actions
-            %a.btn.btn-sm View file @{{conflictsData.shortCommitSha}}
+            %a.btn.view-file.btn-file-option{":href" => "file.blobLink"}
+              View file @{{conflictsData.shortCommitSha}}
 
         .diff-content.diff-wrap-lines
           .diff-wrap-lines.code.file-content.js-syntax-highlight.white

From ad0b5ffbb5e9ebd6f559347752206305408fd705 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Wed, 3 Aug 2016 18:04:00 +0300
Subject: [PATCH 48/90] Draw side-by-side view only one table.

---
 .../merge_conflict_data_provider.js.es6       | 54 +++++++++++-------
 .../stylesheets/pages/merge_conflicts.scss    | 55 +++++++++++++++----
 .../merge_requests/conflicts.html.haml        | 51 ++++++++++-------
 3 files changed, 108 insertions(+), 52 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 2b84d9b694d..183ba1a7864 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -53,14 +53,15 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
   setParallelLines(data) {
     data.files.forEach( (file) => {
       file.filePath = this.getFilePath(file);
-      file.parallelLines = { left: [], right: [] };
+      file.parallelLines = [];
+      const linesObj = { left: [], right: [] };
 
       file.sections.forEach( (section) => {
         const { conflict, lines, id } = section;
 
         if (conflict) {
-          file.parallelLines.left.push(this.getOriginHeaderLine(id));
-          file.parallelLines.right.push(this.getHeadHeaderLine(id));
+          linesObj.left.push(this.getOriginHeaderLine(id));
+          linesObj.right.push(this.getHeadHeaderLine(id));
         }
 
         lines.forEach( (line) => {
@@ -68,40 +69,49 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
           if (conflict) {
             if (type === 'old') {
-              file.parallelLines.left.push(this.getLineForParallelView(line, id, 'conflict'));
+              linesObj.left.push(this.getLineForParallelView(line, id, 'conflict'));
             }
             else if (type === 'new') {
-              file.parallelLines.right.push(this.getLineForParallelView(line, id, 'conflict', true));
+              linesObj.right.push(this.getLineForParallelView(line, id, 'conflict', true));
             }
           }
           else {
             const lineType = type || 'context';
 
-            file.parallelLines.left.push (this.getLineForParallelView(line, id, lineType));
-            file.parallelLines.right.push(this.getLineForParallelView(line, id, lineType, true));
+            linesObj.left.push (this.getLineForParallelView(line, id, lineType));
+            linesObj.right.push(this.getLineForParallelView(line, id, lineType, true));
           }
         });
 
-        this.checkLineLengths(file);
+        this.checkLineLengths(linesObj);
       });
+
+      for (let i = 0, len = linesObj.left.length; i < len; i++) {
+        file.parallelLines.push([
+          linesObj.left[i],
+          linesObj.right[i]
+        ]);
+      }
+
     });
+
   }
 
 
-  checkLineLengths(file) {
-    let { left, right } = file.parallelLines;
+  checkLineLengths(linesObj) {
+    let { left, right } = linesObj;
 
     if (left.length !== right.length) {
       if (left.length > right.length) {
         const diff = left.length - right.length;
         for (let i = 0; i < diff; i++) {
-          file.parallelLines.right.push({ lineType: 'emptyLine', richText: '' });
+          right.push({ lineType: 'emptyLine', richText: '' });
         }
       }
       else {
         const diff = right.length - left.length;
         for (let i = 0; i < diff; i++) {
-          file.parallelLines.left.push({ lineType: 'emptyLine', richText: '' });
+          left.push({ lineType: 'emptyLine', richText: '' });
         }
       }
     }
@@ -152,16 +162,18 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
         }
       });
 
+      file.parallelLines.forEach( (lines) => {
+        const left         = lines[0];
+        const right        = lines[1];
+        const hasSameId    = right.id === sectionId || left.id === sectionId;
+        const isLeftMatch  = left.hasConflict || left.isHeader;
+        const isRightMatch = right.hasConflict || right.isHeader;
 
-      for (section in file.parallelLines) {
-        const lines = file.parallelLines[section];
-
-        lines.forEach( (line) => {
-          if (line.id === sectionId && (line.hasConflict || line.isHeader )) {
-            this.markLine(line, selection);
-          }
-        })
-      }
+        if (hasSameId && (isLeftMatch || isRightMatch)) {
+          this.markLine(left, selection);
+          this.markLine(right, selection);
+        }
+      })
     });
   }
 
diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index a0309113054..965348b3b88 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -19,6 +19,50 @@ $unselected_line:         #f8f8f8;
     min-height: 19px;
   }
 
+
+  .header.line_content, .diff-line-num {
+    &.origin {
+      background-color: $origin_gutter;
+      &.selected {
+        background-color: $selected_origin_gutter;
+      }
+      &.unselected {
+        background-color: $unselected_gutter;
+      }
+    }
+    &.head {
+      background-color: $head_gutter;
+      &.selected {
+        background-color: $selected_head_gutter;
+      }
+      &.unselected {
+        background-color: $unselected_gutter;
+      }
+    }
+  }
+
+  .line_content {
+    &.origin {
+      background-color: $origin_line;
+      &.selected {
+        background-color: $selected_origin_line;
+      }
+      &.unselected {
+        background-color: $unselected_line;
+      }
+    }
+    &.head {
+      background-color: $head_line;
+      &.selected {
+        background-color: $selected_head_line;
+      }
+      &.unselected {
+        background-color: $unselected_line;
+      }
+    }
+  }
+
+
   .head {
     .header, .diff-line-num {
       background-color: $head_gutter;
@@ -71,17 +115,6 @@ $unselected_line:         #f8f8f8;
     }
   }
 
-  .parallel-view {
-    .diff-content {
-      overflow: hidden;
-
-      table {
-        width: 50%;
-        float: left;
-      }
-    }
-  }
-
   .parallel .header {
     button {
       right: 10px;
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index b24bd412815..d667dbe19bc 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -43,30 +43,41 @@
           .file-actions
             %a.btn.view-file.btn-file-option{":href" => "file.blobLink"}
               View file @{{conflictsData.shortCommitSha}}
-
         .diff-content.diff-wrap-lines
           .diff-wrap-lines.code.file-content.js-syntax-highlight.white
-            %table{"v-for" => "(key, group) in file.parallelLines"}
-              %tr.line_holder.parallel{"v-for" => "line in group", |
-                ":class" => "{ |
-                  'head': line.isHead, |
-                  'origin': line.isOrigin, |
-                  'match': line.hasMatch, |
-                  'selected': line.isSelected, |
-                  'unselected': line.isUnselected }"}
+            %table
+              %tr.line_holder.parallel{"v-for" => "section in file.parallelLines"}
+                %template{"v-for" => "line in section"}
 
-                %template{"v-if" => "line.isHeader"}
-                  %td.diff-line-num.header
-                  %td.line_content.header
-                    %strong {{line.richText}}
-                    %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
-
-                %template{"v-if" => "!line.isHeader"}
-                  %td.diff-line-num.old_line
-                    {{line.lineNumber}}
-                  %td.line_content
-                    {{{line.richText}}}
+                  %template{"v-if" => "line.isHeader"}
+                    %td.diff-line-num.header{":class" => "{ |
+                      'head': line.isHead, |
+                      'origin': line.isOrigin, |
+                      'selected': line.isSelected, |
+                      'unselected': line.isUnselected}"}
+                    %td.line_content.header{":class" => "{ |
+                      'head': line.isHead, |
+                      'origin': line.isOrigin, |
+                      'selected': line.isSelected, |
+                      'unselected': line.isUnselected}"}
+                      %strong {{line.richText}}
+                      %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
 
+                  %template{"v-if" => "!line.isHeader"}
+                    %td.diff-line-num.old_line{":class" => "{ |
+                      'head': line.isHead, |
+                      'origin': line.isOrigin, |
+                      'match': line.hasMatch, |
+                      'selected': line.isSelected, |
+                      'unselected': line.isUnselected }"}
+                      {{line.lineNumber}}
+                    %td.line_content.parallel{":class" => "{ |
+                      'head': line.isHead, |
+                      'origin': line.isOrigin, |
+                      'match': line.hasMatch, |
+                      'selected': line.isSelected, |
+                      'unselected': line.isUnselected }"}
+                      {{{line.richText}}}
 
     .files{"v-if" => "!isParallel"}
       .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}

From 912cc7b86219d14f00115c94504c41791d1b5700 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Wed, 3 Aug 2016 21:28:22 +0300
Subject: [PATCH 49/90] Add file icon and blob link.

---
 .../javascripts/merge_conflict_data_provider.js.es6    | 10 +++++++---
 app/views/projects/merge_requests/conflicts.html.haml  | 10 ++++++----
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 183ba1a7864..f0f51a65b94 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -52,7 +52,9 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
   setParallelLines(data) {
     data.files.forEach( (file) => {
-      file.filePath = this.getFilePath(file);
+      file.filePath  = this.getFilePath(file);
+      file.iconClass = `fa-${file.blob_icon}`;
+      file.blobPath  = file.blob_path;
       file.parallelLines = [];
       const linesObj = { left: [], right: [] };
 
@@ -120,8 +122,10 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
   setInlineLines(data) {
     data.files.forEach( (file) => {
+      file.iconClass   = `fa-${file.blob_icon}`;
+      file.blobPath    = file.blob_path;
+      file.filePath    = this.getFilePath(file);
       file.inlineLines = []
-      file.filePath = this.getFilePath(file);
 
       file.sections.forEach( (section) => {
         let currentLineType = 'new';
@@ -309,7 +313,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
   getFilePath(file) {
     const { old_path, new_path } = file;
-    return old_path === new_path ? new_path : `${old_path} &rarr; ${new_path}`;
+    return old_path === new_path ? new_path : `${old_path} → ${new_path}`;
   }
 
 }
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index d667dbe19bc..154999f5309 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -39,9 +39,10 @@
     .files{"v-if" => "isParallel"}
       .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
         .file-title
-          %span {{{file.filePath}}}
+          %i.fa.fa-fw.fa{":class" => "file.iconClass"}
+          %strong {{file.filePath}}
           .file-actions
-            %a.btn.view-file.btn-file-option{":href" => "file.blobLink"}
+            %a.btn.view-file.btn-file-option{":href" => "file.blobPath"}
               View file @{{conflictsData.shortCommitSha}}
         .diff-content.diff-wrap-lines
           .diff-wrap-lines.code.file-content.js-syntax-highlight.white
@@ -82,9 +83,10 @@
     .files{"v-if" => "!isParallel"}
       .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}
         .file-title
-          %span {{{file.filePath}}}
+          %i.fa.fa-fw{":class" => "file.iconClass"}
+          %strong {{file.filePath}}
           .file-actions
-            %a.btn.view-file.btn-file-option{":href" => "file.blobLink"}
+            %a.btn.view-file.btn-file-option{":href" => "file.blobPath"}
               View file @{{conflictsData.shortCommitSha}}
 
         .diff-content.diff-wrap-lines

From 5277239c3e2d843f04397dce572a647f3bd79bdf Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Wed, 3 Aug 2016 23:22:58 +0300
Subject: [PATCH 50/90] Prefer v-show instead of v-if.

---
 app/views/projects/merge_requests/conflicts.html.haml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index 154999f5309..14252fd3256 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -36,7 +36,7 @@
         %strong {{conflictsData.target_branch}}
 
   .files-wrapper{"v-if" => "!isLoading && !hasError"}
-    .files{"v-if" => "isParallel"}
+    .files{"v-show" => "isParallel"}
       .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
         .file-title
           %i.fa.fa-fw.fa{":class" => "file.iconClass"}
@@ -80,7 +80,7 @@
                       'unselected': line.isUnselected }"}
                       {{{line.richText}}}
 
-    .files{"v-if" => "!isParallel"}
+    .files{"v-show" => "!isParallel"}
       .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}
         .file-title
           %i.fa.fa-fw{":class" => "file.iconClass"}

From 427e724698185169536d68e95873415038286849 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Thu, 4 Aug 2016 10:31:44 +0100
Subject: [PATCH 51/90] Don't allow resolving invalid conflicts

An MR can only be resolved in the UI if:
- It has conflicts.
- It has valid diff_refs (in other words, it supports new diff notes).
- It has no conflicts with one side missing.
- It has no conflicts in binary files.
- It has no conflicts in files too large to display.
- It has no conflicts containing invalid conflict markers.
---
 .../projects/merge_requests_controller.rb     | 10 ++++----
 app/models/diff_note.rb                       |  2 +-
 app/models/merge_request.rb                   | 23 +++++++++++++++----
 .../widget/open/_conflicts.html.haml          |  6 ++---
 lib/gitlab/conflict/file.rb                   |  4 ++--
 5 files changed, 29 insertions(+), 16 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 42dc0bb4a43..040dceff142 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -132,15 +132,13 @@ class Projects::MergeRequestsController < Projects::ApplicationController
   end
 
   def conflicts
-    return render_404 unless @merge_request.cannot_be_merged?
-
     respond_to do |format|
       format.html { define_discussion_vars }
 
       format.json do
-        begin
-          render json: Gitlab::Conflict::FileCollection.new(@merge_request)
-        rescue Gitlab::Conflict::Parser::ParserError, Gitlab::Conflict::FileCollection::ConflictSideMissing
+        if @merge_request.can_resolve_conflicts_in_ui?
+          render json: @merge_request.conflicts
+        else
           render json: {
             message: 'Unable to resolve conflicts in the web interface for this merge request',
             type: 'error'
@@ -452,7 +450,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
       noteable_id: @merge_request.id
     }
 
-    @use_legacy_diff_notes = !@merge_request.support_new_diff_notes?
+    @use_legacy_diff_notes = !@merge_request.has_complete_diff_refs?
     @grouped_diff_discussions = @merge_request.notes.inc_author_project_award_emoji.grouped_diff_discussions
 
     Banzai::NoteRenderer.render(
diff --git a/app/models/diff_note.rb b/app/models/diff_note.rb
index c816deb4e0c..e02a3d54c36 100644
--- a/app/models/diff_note.rb
+++ b/app/models/diff_note.rb
@@ -75,7 +75,7 @@ class DiffNote < Note
   private
 
   def supported?
-    !self.for_merge_request? || self.noteable.support_new_diff_notes?
+    !self.for_merge_request? || self.noteable.has_complete_diff_refs?
   end
 
   def noteable_diff_refs
diff --git a/app/models/merge_request.rb b/app/models/merge_request.rb
index e87ce322098..630d31a5d5c 100644
--- a/app/models/merge_request.rb
+++ b/app/models/merge_request.rb
@@ -204,7 +204,7 @@ class MergeRequest < ActiveRecord::Base
 
   def diff_start_commit
     if persisted?
-      merge_request_diff.start_commit || target_branch_head
+      merge_request_diff.start_commit
     else
       target_branch_head
     end
@@ -212,7 +212,7 @@ class MergeRequest < ActiveRecord::Base
 
   def diff_head_commit
     if persisted?
-      merge_request_diff.head_commit || source_branch_head
+      merge_request_diff.head_commit
     else
       source_branch_head
     end
@@ -682,12 +682,12 @@ class MergeRequest < ActiveRecord::Base
     merge_commit
   end
 
-  def support_new_diff_notes?
+  def has_complete_diff_refs?
     diff_sha_refs && diff_sha_refs.complete?
   end
 
   def update_diff_notes_positions(old_diff_refs:, new_diff_refs:)
-    return unless support_new_diff_notes?
+    return unless has_complete_diff_refs?
     return if new_diff_refs == old_diff_refs
 
     active_diff_notes = self.notes.diff_notes.select do |note|
@@ -715,4 +715,19 @@ class MergeRequest < ActiveRecord::Base
   def keep_around_commit
     project.repository.keep_around(self.merge_commit_sha)
   end
+
+  def conflicts
+    @conflicts ||= Gitlab::Conflict::FileCollection.new(self)
+  end
+
+  def can_resolve_conflicts_in_ui?
+    return false unless cannot_be_merged?
+    return false unless has_complete_diff_refs?
+
+    begin
+      conflicts.files.each(&:lines)
+    rescue Gitlab::Conflict::Parser::ParserError, Gitlab::Conflict::FileCollection::ConflictSideMissing
+      false
+    end
+  end
 end
diff --git a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
index 6bdbbb94f09..582a82c7a71 100644
--- a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
@@ -4,9 +4,9 @@
 
 %p
   Please
-  = link_to conflicts_namespace_project_merge_request_path(@project.namespace, @project, @merge_request) do
-    resolve these conflicts
-  or
+  - if @merge_request.can_resolve_conflicts_in_ui?
+    = link_to "resolve these conflicts", conflicts_namespace_project_merge_request_path(@project.namespace, @project, @merge_request)
+    or
   - if @merge_request.can_be_merged_via_command_line_by?(current_user)
     #{link_to "merge this request manually", "#modal_merge_info", class: "how_to_merge_link vlink", "data-toggle" => "modal"}.
   - else
diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 1d63aec6903..cdbb63f626f 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -69,9 +69,9 @@ module Gitlab
 
         lines.each do |line|
           if line.type == 'old'
-            line.rich_text = their_highlight[line.old_line - 1].html_safe
+            line.rich_text = their_highlight[line.old_line - 1].try(:html_safe)
           else
-            line.rich_text = our_highlight[line.new_line - 1].html_safe
+            line.rich_text = our_highlight[line.new_line - 1].try(:html_safe)
           end
         end
       end

From ac9229a31be8e672efdcc63b702a2039ae66ad46 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Thu, 4 Aug 2016 14:12:08 +0100
Subject: [PATCH 52/90] Clarify Conflict::File#sections method

---
 lib/gitlab/conflict/file.rb           | 22 +++++++++++++++++++---
 spec/lib/gitlab/conflict/file_spec.rb | 25 +++++++++++++------------
 2 files changed, 32 insertions(+), 15 deletions(-)

diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index cdbb63f626f..6284b0dd377 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -79,6 +79,9 @@ module Gitlab
       def sections
         return @sections if @sections
 
+        # Any line beginning with a letter, an underscore, or a dollar can be used in a
+        # match line header. Only context sections can contain match lines, as match lines
+        # have to exist in both versions of the file.
         candidate_match_headers = lines.map do |line|
           " #{line.text}" if line.text.match(/\A[A-Za-z$_]/) && line.type.nil?
         end
@@ -89,19 +92,24 @@ module Gitlab
         @sections = chunked_lines.flat_map.with_index do |(no_conflict, lines), i|
           section = nil
 
+          # We need to reduce context sections to CONTEXT_LINES. Conflict sections are
+          # always shown in full.
           if no_conflict
             conflict_before = i > 0
             conflict_after = chunked_lines.peek
 
             if conflict_before && conflict_after
+              # Create a gap in a long context section.
               if lines.length > CONTEXT_LINES * 2
                 head_lines = lines.first(CONTEXT_LINES)
                 tail_lines = lines.last(CONTEXT_LINES)
 
+                # Ensure any existing match line has text for all lines up to the last
+                # line of its context.
                 update_match_line_text(match_line, head_lines.last, candidate_match_headers)
 
+                # Insert a new match line after the created gap.
                 match_line = create_match_line(tail_lines.first)
-                update_match_line_text(match_line, tail_lines.last, candidate_match_headers)
 
                 section = [
                   { conflict: false, lines: head_lines },
@@ -111,7 +119,8 @@ module Gitlab
             elsif conflict_after
               tail_lines = lines.last(CONTEXT_LINES)
 
-              if lines.length > CONTEXT_LINES
+              # Create a gap and insert a match line at the start.
+              if lines.length > tail_lines.length
                 match_line = create_match_line(tail_lines.first)
 
                 tail_lines.unshift(match_line)
@@ -119,10 +128,14 @@ module Gitlab
 
               lines = tail_lines
             elsif conflict_before
+              # We're at the end of the file (no conflicts after), so just remove extra
+              # trailing lines.
               lines = lines.first(CONTEXT_LINES)
             end
           end
 
+          # We want to update the match line's text every time unless we've already
+          # created a gap and its corresponding match line.
           update_match_line_text(match_line, lines.last, candidate_match_headers) unless section
 
           section ||= { conflict: !no_conflict, lines: lines }
@@ -139,10 +152,13 @@ module Gitlab
         Gitlab::Diff::Line.new('', 'match', line.index, line.old_pos, line.new_pos)
       end
 
+      # Set the match line's text for the current line. A match line takes its start
+      # position and context header (where present) from itself, and its end position from
+      # the line passed in.
       def update_match_line_text(match_line, line, headers)
         return unless match_line
 
-        header = headers.first(line.index).compact.last
+        header = headers.first(match_line.index).compact.last
 
         match_line.text = "@@ -#{match_line.old_pos},#{line.old_pos} +#{match_line.new_pos},#{line.new_pos} @@#{header}"
       end
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index cf670b3182a..405b97686f5 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -86,19 +86,20 @@ describe Gitlab::Conflict::File, lib: true do
   end
 
   describe '#sections' do
-    it 'returns match lines when there is a gap between sections' do
-      section = conflict_file.sections[5]
-      match_line = section[:lines][0]
-
-      expect(section[:conflict]).to be_falsey
-      expect(match_line.type).to eq('match')
-      expect(match_line.text).to eq('@@ -46,53 +46,53 @@ module Gitlab')
-    end
-
-    it 'does not return match lines when there is no gap between sections' do
+    it 'only inserts match lines when there is a gap between sections' do
       conflict_file.sections.each_with_index do |section, i|
-        unless i == 5
-          expect(section[:lines][0].type).not_to eq(5)
+        previous_line_number = 0
+        current_line_number = section[:lines].map(&:old_line).compact.min
+
+        if i > 0
+          previous_line_number = conflict_file.sections[i - 1][:lines].map(&:old_line).compact.last
+        end
+
+        if current_line_number == previous_line_number + 1
+          expect(section[:lines].first.type).not_to eq('match')
+        else
+          expect(section[:lines].first.type).to eq('match')
+          expect(section[:lines].first.text).to match(/\A@@ -#{current_line_number},\d+ \+\d+,\d+ @@ module Gitlab\Z/)
         end
       end
     end

From ba327e69ec4b2214f12f577cd86a37c65ea2f3e9 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Thu, 4 Aug 2016 14:20:04 +0100
Subject: [PATCH 53/90] Move resolving code to ResolveService

---
 .../projects/merge_requests_controller.rb     |  2 +-
 app/models/repository.rb                      |  8 +++++
 .../merge_requests/resolve_service.rb         | 31 +++++++++++++++++++
 lib/gitlab/conflict/file.rb                   |  8 -----
 lib/gitlab/conflict/file_collection.rb        | 21 -------------
 5 files changed, 40 insertions(+), 30 deletions(-)
 create mode 100644 app/services/merge_requests/resolve_service.rb

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 040dceff142..27d54f6b46f 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -150,7 +150,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
 
   def resolve_conflicts
     begin
-      Gitlab::Conflict::FileCollection.new(@merge_request).resolve_conflicts!(params, user: current_user)
+      MergeRequests::ResolveService.new(project, current_user, params).execute(@merge_request)
 
       head :ok
     rescue Gitlab::Conflict::File::MissingResolution => e
diff --git a/app/models/repository.rb b/app/models/repository.rb
index e56bac509a4..01b02ccc0dc 100644
--- a/app/models/repository.rb
+++ b/app/models/repository.rb
@@ -869,6 +869,14 @@ class Repository
     end
   end
 
+  def resolve_conflicts(user, branch, params)
+    commit_with_hooks(user, branch) do
+      committer = user_to_committer(user)
+
+      Rugged::Commit.create(rugged, params.merge(author: committer, committer: committer))
+    end
+  end
+
   def check_revert_content(commit, base_branch)
     source_sha = find_branch(base_branch).target.sha
     args       = [commit.id, source_sha]
diff --git a/app/services/merge_requests/resolve_service.rb b/app/services/merge_requests/resolve_service.rb
new file mode 100644
index 00000000000..adc71b0c2bc
--- /dev/null
+++ b/app/services/merge_requests/resolve_service.rb
@@ -0,0 +1,31 @@
+module MergeRequests
+  class ResolveService < MergeRequests::BaseService
+    attr_accessor :conflicts, :rugged, :merge_index
+
+    def execute(merge_request)
+      @conflicts = merge_request.conflicts
+      @rugged = project.repository.rugged
+      @merge_index = conflicts.merge_index
+
+      conflicts.files.each do |file|
+        write_resolved_file_to_index(file, params[:sections])
+      end
+
+      commit_params = {
+        message: params[:commit_message] || conflicts.default_commit_message,
+        parents: [conflicts.our_commit, conflicts.their_commit].map(&:oid),
+        tree: merge_index.write_tree(rugged)
+      }
+
+      project.repository.resolve_conflicts(current_user, merge_request.source_branch, commit_params)
+    end
+
+    def write_resolved_file_to_index(file, resolutions)
+      new_file = file.resolve_lines(resolutions).map(&:text).join("\n")
+      our_path = file.our_path
+
+      merge_index.add(path: our_path, oid: rugged.write(new_file, :blob), mode: file.our_mode)
+      merge_index.conflict_remove(our_path)
+    end
+  end
+end
diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 6284b0dd377..3560fae5b09 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -28,14 +28,6 @@ module Gitlab
                                                       parent_file: self)
       end
 
-      def resolve!(resolution, index:, rugged:)
-        new_file = resolve_lines(resolution).map(&:text).join("\n")
-
-        oid = rugged.write(new_file, :blob)
-        index.add(path: our_path, oid: oid, mode: our_mode)
-        index.conflict_remove(our_path)
-      end
-
       def resolve_lines(resolution)
         section_id = nil
 
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index 04a75f9edc3..e8157fb9e91 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -20,27 +20,6 @@ module Gitlab
         @merge_index ||= repository.rugged.merge_commits(our_commit, their_commit)
       end
 
-      def resolve_conflicts!(params, user:)
-        resolutions = params[:sections]
-        commit_message = params[:commit_message] || default_commit_message
-        rugged = repository.rugged
-        committer = repository.user_to_committer(user)
-
-        files.each do |file|
-          file.resolve!(resolutions, index: merge_index, rugged: rugged)
-        end
-
-        new_tree = merge_index.write_tree(rugged)
-
-        Rugged::Commit.create(rugged,
-                              author: committer,
-                              committer: committer,
-                              tree: new_tree,
-                              message: commit_message,
-                              parents: [our_commit, their_commit].map(&:oid),
-                              update_ref: Gitlab::Git::BRANCH_REF_PREFIX + merge_request.source_branch)
-      end
-
       def files
         @files ||= merge_index.conflicts.map do |conflict|
           raise ConflictSideMissing unless conflict[:theirs] && conflict[:ours]

From 46f8e6421adc9e2e30c8c3f58fe0e00ae326f0c5 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Thu, 4 Aug 2016 14:32:10 +0100
Subject: [PATCH 54/90] Remove undo endpoint

This reverts commit 2536fea8db0967a817615eb3e951eb6ba22f8ede.
---
 .../projects/merge_requests_controller.rb           | 13 +------------
 config/routes.rb                                    |  1 -
 .../projects/merge_requests_controller_spec.rb      | 13 -------------
 3 files changed, 1 insertion(+), 26 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 27d54f6b46f..2e6ebdf1d94 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -10,8 +10,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
   before_action :module_enabled
   before_action :merge_request, only: [
     :edit, :update, :show, :diffs, :commits, :conflicts, :builds, :merge, :merge_check,
-    :ci_status, :toggle_subscription, :cancel_merge_when_build_succeeds, :remove_wip, :resolve_conflicts,
-    :undo_last_resolution
+    :ci_status, :toggle_subscription, :cancel_merge_when_build_succeeds, :remove_wip, :resolve_conflicts
   ]
   before_action :validates_merge_request, only: [:show, :diffs, :commits, :builds]
   before_action :define_show_vars, only: [:show, :diffs, :commits, :conflicts, :builds]
@@ -158,16 +157,6 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     end
   end
 
-  def undo_last_resolution
-    rugged = @merge_request.project.repository.rugged
-    ref = Gitlab::Git::BRANCH_REF_PREFIX + @merge_request.source_branch
-    prev = rugged.ref(ref).target
-
-    rugged.references.update(ref, prev.parents.first.oid) if prev.parents.length == 2
-
-    head :ok
-  end
-
   def builds
     respond_to do |format|
       format.html do
diff --git a/config/routes.rb b/config/routes.rb
index 91d33ea43e9..93da084b64a 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -729,7 +729,6 @@ Rails.application.routes.draw do
             post :remove_wip
             get :diff_for_path
             post :resolve_conflicts
-            post :undo_last_resolution
           end
 
           collection do
diff --git a/spec/controllers/projects/merge_requests_controller_spec.rb b/spec/controllers/projects/merge_requests_controller_spec.rb
index 7d1028c11bf..88bab0c08e8 100644
--- a/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -639,19 +639,6 @@ describe Projects::MergeRequestsController do
       it 'returns an OK resposne' do
         expect(response).to have_http_status(:ok)
       end
-
-      context 'undoing the resolution' do
-        before do
-          post :undo_last_resolution,
-               namespace_id: merge_request_with_conflicts.project.namespace.to_param,
-               project_id: merge_request_with_conflicts.project.to_param,
-               id: merge_request_with_conflicts.iid
-        end
-
-        it 'undoes the commit' do
-          expect(original_head_sha).to eq(merge_request_with_conflicts.source_branch_head.sha)
-        end
-      end
     end
 
     context 'when sections are missing' do

From f322c3027442b8f8c4800c19056bcd967be4018b Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Thu, 4 Aug 2016 14:56:54 +0100
Subject: [PATCH 55/90] Set flash message after conflict is resolved

---
 app/assets/javascripts/merge_conflict_resolver.js.es6       | 4 ++--
 app/controllers/projects/merge_requests_controller.rb       | 5 ++++-
 app/views/projects/merge_requests/widget/_heading.html.haml | 6 ++++++
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index 6da5bf6568e..cff43a3b40f 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -59,8 +59,8 @@ window.MergeConflictResolver = class MergeConflictResolver {
 
   commit() {
     $.post('./resolve_conflicts', this.dataProvider.getCommitData())
-      .always( (data) => {
-        console.log(data)
+      .then( (data) => {
+        window.location.href = data.redirect_to
       })
   }
 
diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 2e6ebdf1d94..a3e02f84f88 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -151,7 +151,10 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     begin
       MergeRequests::ResolveService.new(project, current_user, params).execute(@merge_request)
 
-      head :ok
+      flash[:conflicts_message] = 'Merge conflicts resolved.'
+      flash.keep
+
+      render json: { redirect_to: namespace_project_merge_request_url(@project.namespace, @project, @merge_request) }
     rescue Gitlab::Conflict::File::MissingResolution => e
       render status: :bad_request, json: { message: e.message }
     end
diff --git a/app/views/projects/merge_requests/widget/_heading.html.haml b/app/views/projects/merge_requests/widget/_heading.html.haml
index 6ef640bb654..4e96ab0595a 100644
--- a/app/views/projects/merge_requests/widget/_heading.html.haml
+++ b/app/views/projects/merge_requests/widget/_heading.html.haml
@@ -42,3 +42,9 @@
     .ci_widget.ci-error{style: "display:none"}
       = icon("times-circle")
       Could not connect to the CI server. Please check your settings and try again.
+
+- if flash[:conflicts_message]
+  .mr-widget-heading
+    .ci_widget
+      = ci_icon_for_status('success')
+      = flash[:conflicts_message]

From ce7eb4e49279ab56cac992b6743fe77cac578b48 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 5 Aug 2016 12:15:06 +0100
Subject: [PATCH 56/90] Add more tests for conflicts

---
 .../projects/merge_requests_controller.rb     |  2 +-
 lib/gitlab/conflict/file_collection.rb        |  2 +-
 .../merge_requests_controller_spec.rb         |  8 +--
 .../features/merge_requests/conflicts_spec.rb | 68 +++++++++++++++++++
 .../gitlab/conflict/file_collection_spec.rb   |  4 +-
 spec/lib/gitlab/conflict/file_spec.rb         |  6 +-
 spec/models/merge_request_spec.rb             | 52 ++++++++++++++
 spec/support/test_env.rb                      | 46 +++++++------
 8 files changed, 156 insertions(+), 32 deletions(-)
 create mode 100644 spec/features/merge_requests/conflicts_spec.rb

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index a3e02f84f88..2edd76de4c4 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -139,7 +139,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
           render json: @merge_request.conflicts
         else
           render json: {
-            message: 'Unable to resolve conflicts in the web interface for this merge request',
+            message: 'Unable to resolve conflicts in the web interface for this merge request.',
             type: 'error'
           }
         end
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index e8157fb9e91..bbd0427a2c8 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -46,7 +46,7 @@ module Gitlab
         end
 
         <<EOM.chomp
-Merge branch '#{merge_request.source_branch}' into '#{merge_request.target_branch}'
+Merge branch '#{merge_request.target_branch}' into '#{merge_request.source_branch}'
 
 # Conflicts:
 #{conflict_filenames.join("\n")}
diff --git a/spec/controllers/projects/merge_requests_controller_spec.rb b/spec/controllers/projects/merge_requests_controller_spec.rb
index 88bab0c08e8..c64c2b075c5 100644
--- a/spec/controllers/projects/merge_requests_controller_spec.rb
+++ b/spec/controllers/projects/merge_requests_controller_spec.rb
@@ -5,7 +5,7 @@ describe Projects::MergeRequestsController do
   let(:user)    { create(:user) }
   let(:merge_request) { create(:merge_request_with_diffs, target_project: project, source_project: project) }
   let(:merge_request_with_conflicts) do
-    create(:merge_request, source_branch: 'conflict-a', target_branch: 'conflict-b', source_project: project) do |mr|
+    create(:merge_request, source_branch: 'conflict-resolvable', target_branch: 'conflict-start', source_project: project) do |mr|
       mr.mark_as_unmergeable
     end
   end
@@ -625,7 +625,7 @@ describe Projects::MergeRequestsController do
 
     context 'with valid params' do
       before do
-        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_4_4' => 'head',
+        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_14_14' => 'head',
                           '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_9_9' => 'head',
                           '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_21_21' => 'origin',
                           '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_49_49' => 'origin')
@@ -636,14 +636,14 @@ describe Projects::MergeRequestsController do
         expect(merge_request_with_conflicts.source_branch_head.message).to include('Commit message')
       end
 
-      it 'returns an OK resposne' do
+      it 'returns an OK response' do
         expect(response).to have_http_status(:ok)
       end
     end
 
     context 'when sections are missing' do
       before do
-        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_4_4' => 'head')
+        resolve_conflicts('2f6fcd96b88b36ce98c38da085c795a27d92a3dd_14_14' => 'head')
       end
 
       it 'returns a 400 error' do
diff --git a/spec/features/merge_requests/conflicts_spec.rb b/spec/features/merge_requests/conflicts_spec.rb
new file mode 100644
index 00000000000..0b39b4dbebb
--- /dev/null
+++ b/spec/features/merge_requests/conflicts_spec.rb
@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+feature 'Merge request conflict resolution', js: true, feature: true do
+  include WaitForAjax
+
+  let(:user) { create(:user) }
+  let(:project) { create(:project) }
+
+  def create_merge_request(source_branch)
+    create(:merge_request, source_branch: source_branch, target_branch: 'conflict-start', source_project: project) do |mr|
+      mr.mark_as_unmergeable
+    end
+  end
+
+  context 'when a merge request can be resolved in the UI' do
+    let(:merge_request) { create_merge_request('conflict-resolvable') }
+
+    before do
+      project.team << [user, :developer]
+      login_as(user)
+
+      visit namespace_project_merge_request_path(project.namespace, project, merge_request)
+    end
+
+    it 'shows a link to the conflict resolution page' do
+      expect(page).to have_link('conflicts', href: /\/conflicts\Z/)
+    end
+
+    context 'visiting the conflicts resolution page' do
+      before { click_link('conflicts', href: /\/conflicts\Z/) }
+
+      it 'shows the conflicts' do
+        expect(find('#conflicts')).to have_content('popen.rb')
+      end
+    end
+  end
+
+  UNRESOLVABLE_CONFLICTS = {
+    'conflict-too-large' => 'when the conflicts contain a large file',
+    'conflict-binary-file' => 'when the conflicts contain a binary file',
+    'conflict-contains-conflict-markers' => 'when the conflicts contain a file with ambiguous conflict markers',
+    'conflict-missing-side' => 'when the conflicts contain a file edited in one branch and deleted in another'
+  }
+
+  UNRESOLVABLE_CONFLICTS.each do |source_branch, description|
+    context description do
+      let(:merge_request) { create_merge_request(source_branch) }
+
+      before do
+        project.team << [user, :developer]
+        login_as(user)
+
+        visit namespace_project_merge_request_path(project.namespace, project, merge_request)
+      end
+
+      it 'does not show a link to the conflict resolution page' do
+        expect(page).not_to have_link('conflicts', href: /\/conflicts\Z/)
+      end
+
+      it 'shows an error if the conflicts page is visited directly' do
+        visit current_url + '/conflicts'
+        wait_for_ajax
+
+        expect(find('#conflicts')).to have_content('Unable to resolve conflicts')
+      end
+    end
+  end
+end
diff --git a/spec/lib/gitlab/conflict/file_collection_spec.rb b/spec/lib/gitlab/conflict/file_collection_spec.rb
index 2a09adb2321..39d892c18c0 100644
--- a/spec/lib/gitlab/conflict/file_collection_spec.rb
+++ b/spec/lib/gitlab/conflict/file_collection_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Gitlab::Conflict::FileCollection, lib: true do
-  let(:merge_request) { create(:merge_request, source_branch: 'conflict-a', target_branch: 'conflict-b') }
+  let(:merge_request) { create(:merge_request, source_branch: 'conflict-resolvable', target_branch: 'conflict-start') }
   let(:file_collection) { Gitlab::Conflict::FileCollection.new(merge_request) }
 
   describe '#files' do
@@ -13,7 +13,7 @@ describe Gitlab::Conflict::FileCollection, lib: true do
   describe '#default_commit_message' do
     it 'matches the format of the git CLI commit message' do
       expect(file_collection.default_commit_message).to eq(<<EOM.chomp)
-Merge branch 'conflict-a' into 'conflict-b'
+Merge branch 'conflict-start' into 'conflict-resolvable'
 
 # Conflicts:
 #   files/ruby/popen.rb
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index 405b97686f5..643c5b31791 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -4,9 +4,9 @@ describe Gitlab::Conflict::File, lib: true do
   let(:project) { create(:project) }
   let(:repository) { project.repository }
   let(:rugged) { repository.rugged }
-  let(:their_commit) { rugged.branches['conflict-a'].target }
-  let(:our_commit) { rugged.branches['conflict-b'].target }
-  let(:merge_request) { create(:merge_request, source_branch: 'conflict-b', target_branch: 'conflict-a', source_project: project) }
+  let(:their_commit) { rugged.branches['conflict-start'].target }
+  let(:our_commit) { rugged.branches['conflict-resolvable'].target }
+  let(:merge_request) { create(:merge_request, source_branch: 'conflict-resolvable', target_branch: 'conflict-start', source_project: project) }
   let(:index) { rugged.merge_commits(our_commit, their_commit) }
   let(:conflict) { index.conflicts.last }
   let(:merge_file_result) { index.merge_file('files/ruby/regex.rb') }
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index 3270b877c1a..b4741bd3bcb 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -741,4 +741,56 @@ describe MergeRequest, models: true do
       end
     end
   end
+
+  describe '#can_resolve_conflicts_in_ui?' do
+    def create_merge_request(source_branch)
+      create(:merge_request, source_branch: source_branch, target_branch: 'conflict-start') do |mr|
+        mr.mark_as_unmergeable
+      end
+    end
+
+    it 'returns a falsey value when the MR can be merged without conflicts' do
+      merge_request = create_merge_request('master')
+      merge_request.mark_as_mergeable
+
+      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+    end
+
+    it 'returns a falsey value when the MR does not support new diff notes' do
+      merge_request = create_merge_request('conflict-resolvable')
+      merge_request.merge_request_diff.update_attributes(start_commit_sha: nil)
+
+      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+    end
+
+    it 'returns a falsey value when the conflicts contain a large file' do
+      merge_request = create_merge_request('conflict-too-large')
+
+      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+    end
+
+    it 'returns a falsey value when the conflicts contain a binary file' do
+      merge_request = create_merge_request('conflict-binary-file')
+
+      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+    end
+
+    it 'returns a falsey value when the conflicts contain a file with ambiguous conflict markers' do
+      merge_request = create_merge_request('conflict-contains-conflict-markers')
+
+      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+    end
+
+    it 'returns a falsey value when the conflicts contain a file edited in one branch and deleted in another' do
+      merge_request = create_merge_request('conflict-missing-side')
+
+      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+    end
+
+    it 'returns a truthy value when the conflicts are resolvable in the UI' do
+      merge_request = create_merge_request('conflict-resolvable')
+
+      expect(merge_request.can_resolve_conflicts_in_ui?).to be_truthy
+    end
+  end
 end
diff --git a/spec/support/test_env.rb b/spec/support/test_env.rb
index 976b1f36270..edbbfc3c9e5 100644
--- a/spec/support/test_env.rb
+++ b/spec/support/test_env.rb
@@ -5,27 +5,31 @@ module TestEnv
 
   # When developing the seed repository, comment out the branch you will modify.
   BRANCH_SHA = {
-    'empty-branch'          => '7efb185',
-    'ends-with.json'        => '98b0d8b3',
-    'flatten-dir'           => 'e56497b',
-    'feature'               => '0b4bc9a',
-    'feature_conflict'      => 'bb5206f',
-    'fix'                   => '48f0be4',
-    'improve/awesome'       => '5937ac0',
-    'markdown'              => '0ed8c6c',
-    'lfs'                   => 'be93687',
-    'master'                => '5937ac0',
-    "'test'"                => 'e56497b',
-    'orphaned-branch'       => '45127a9',
-    'binary-encoding'       => '7b1cf43',
-    'gitattributes'         => '5a62481',
-    'conflict-a'            => 'dfdd207',
-    'conflict-b'            => '4e75a62',
-    'expand-collapse-diffs' => '4842455',
-    'expand-collapse-files' => '025db92',
-    'expand-collapse-lines' => '238e82d',
-    'video'                 => '8879059',
-    'crlf-diff'             => '5938907'
+    'empty-branch'                       => '7efb185',
+    'ends-with.json'                     => '98b0d8b3',
+    'flatten-dir'                        => 'e56497b',
+    'feature'                            => '0b4bc9a',
+    'feature_conflict'                   => 'bb5206f',
+    'fix'                                => '48f0be4',
+    'improve/awesome'                    => '5937ac0',
+    'markdown'                           => '0ed8c6c',
+    'lfs'                                => 'be93687',
+    'master'                             => '5937ac0',
+    "'test'"                             => 'e56497b',
+    'orphaned-branch'                    => '45127a9',
+    'binary-encoding'                    => '7b1cf43',
+    'gitattributes'                      => '5a62481',
+    'expand-collapse-diffs'              => '4842455',
+    'expand-collapse-files'              => '025db92',
+    'expand-collapse-lines'              => '238e82d',
+    'video'                              => '8879059',
+    'crlf-diff'                          => '5938907',
+    'conflict-start'                     => '14fa46b',
+    'conflict-resolvable'                => '1450cd6',
+    'conflict-binary-file'               => '259a6fb',
+    'conflict-contains-conflict-markers' => '5e0964c',
+    'conflict-missing-side'              => 'eb227b3',
+    'conflict-too-large'                 => '39fa04f',
   }
 
   # gitlab-test-fork is a fork of gitlab-fork, but we don't necessarily

From 4952a24f584aea1e8e878f5ca276b2682422fbd4 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 5 Aug 2016 13:24:15 +0100
Subject: [PATCH 57/90] Find match line headers by backtracking

This is more efficient for large files than performing a regex match on
every single line.
---
 lib/gitlab/conflict/file.rb           |  35 ++++++---
 spec/lib/gitlab/conflict/file_spec.rb | 104 ++++++++++++++++++++++++++
 2 files changed, 128 insertions(+), 11 deletions(-)

diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 3560fae5b09..926b65d46fc 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -18,6 +18,7 @@ module Gitlab
         @our_mode = conflict[:ours][:mode]
         @merge_request = merge_request
         @repository = merge_request.project.repository
+        @match_line_headers = {}
       end
 
       # Array of Gitlab::Diff::Line objects
@@ -71,13 +72,6 @@ module Gitlab
       def sections
         return @sections if @sections
 
-        # Any line beginning with a letter, an underscore, or a dollar can be used in a
-        # match line header. Only context sections can contain match lines, as match lines
-        # have to exist in both versions of the file.
-        candidate_match_headers = lines.map do |line|
-          " #{line.text}" if line.text.match(/\A[A-Za-z$_]/) && line.type.nil?
-        end
-
         chunked_lines = lines.chunk { |line| line.type.nil? }
         match_line = nil
 
@@ -98,7 +92,7 @@ module Gitlab
 
                 # Ensure any existing match line has text for all lines up to the last
                 # line of its context.
-                update_match_line_text(match_line, head_lines.last, candidate_match_headers)
+                update_match_line_text(match_line, head_lines.last)
 
                 # Insert a new match line after the created gap.
                 match_line = create_match_line(tail_lines.first)
@@ -128,7 +122,7 @@ module Gitlab
 
           # We want to update the match line's text every time unless we've already
           # created a gap and its corresponding match line.
-          update_match_line_text(match_line, lines.last, candidate_match_headers) unless section
+          update_match_line_text(match_line, lines.last) unless section
 
           section ||= { conflict: !no_conflict, lines: lines }
           section[:id] = line_code(lines.first) unless no_conflict
@@ -144,13 +138,32 @@ module Gitlab
         Gitlab::Diff::Line.new('', 'match', line.index, line.old_pos, line.new_pos)
       end
 
+      # Any line beginning with a letter, an underscore, or a dollar can be used in a
+      # match line header. Only context sections can contain match lines, as match lines
+      # have to exist in both versions of the file.
+      def find_match_line_header(index)
+        return @match_line_headers[index] if @match_line_headers.key?(index)
+
+        @match_line_headers[index] = begin
+          if index >= 0
+            line = lines[index]
+
+            if line.type.nil? && line.text.match(/\A[A-Za-z$_]/)
+              " #{line.text}"
+            else
+              find_match_line_header(index - 1)
+            end
+          end
+        end
+      end
+
       # Set the match line's text for the current line. A match line takes its start
       # position and context header (where present) from itself, and its end position from
       # the line passed in.
-      def update_match_line_text(match_line, line, headers)
+      def update_match_line_text(match_line, line)
         return unless match_line
 
-        header = headers.first(match_line.index).compact.last
+        header = find_match_line_header(match_line.index - 1)
 
         match_line.text = "@@ -#{match_line.old_pos},#{line.old_pos} +#{match_line.new_pos},#{line.new_pos} @@#{header}"
       end
diff --git a/spec/lib/gitlab/conflict/file_spec.rb b/spec/lib/gitlab/conflict/file_spec.rb
index 643c5b31791..60020487061 100644
--- a/spec/lib/gitlab/conflict/file_spec.rb
+++ b/spec/lib/gitlab/conflict/file_spec.rb
@@ -142,6 +142,110 @@ describe Gitlab::Conflict::File, lib: true do
 
       expect(section_ids.uniq).to eq(section_ids)
     end
+
+    context 'with an example file' do
+      let(:file) do
+        <<FILE
+  # Ensure there is no match line header here
+  def username_regexp
+    default_regexp
+  end
+
+<<<<<<< files/ruby/regex.rb
+def project_name_regexp
+  /\A[a-zA-Z0-9][a-zA-Z0-9_\-\. ]*\z/
+end
+
+def name_regexp
+  /\A[a-zA-Z0-9_\-\. ]*\z/
+=======
+def project_name_regex
+  %r{\A[a-zA-Z0-9][a-zA-Z0-9_\-\. ]*\z}
+end
+
+def name_regex
+  %r{\A[a-zA-Z0-9_\-\. ]*\z}
+>>>>>>> files/ruby/regex.rb
+end
+
+# Some extra lines
+# To force a match line
+# To be created
+
+def path_regexp
+  default_regexp
+end
+
+<<<<<<< files/ruby/regex.rb
+def archive_formats_regexp
+  /(zip|tar|7z|tar\.gz|tgz|gz|tar\.bz2|tbz|tbz2|tb2|bz2)/
+=======
+def archive_formats_regex
+  %r{(zip|tar|7z|tar\.gz|tgz|gz|tar\.bz2|tbz|tbz2|tb2|bz2)}
+>>>>>>> files/ruby/regex.rb
+end
+
+def git_reference_regexp
+  # Valid git ref regexp, see:
+  # https://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
+  %r{
+    (?!
+       (?# doesn't begins with)
+       \/|                    (?# rule #6)
+       (?# doesn't contain)
+       .*(?:
+          [\/.]\.|            (?# rule #1,3)
+          \/\/|               (?# rule #6)
+          @\{|                (?# rule #8)
+          \\                  (?# rule #9)
+       )
+    )
+    [^\000-\040\177~^:?*\[]+  (?# rule #4-5)
+    (?# doesn't end with)
+    (?<!\.lock)               (?# rule #1)
+    (?<![\/.])                (?# rule #6-7)
+  }x
+end
+
+protected
+
+<<<<<<< files/ruby/regex.rb
+def default_regexp
+  /\A[.?]?[a-zA-Z0-9][a-zA-Z0-9_\-\.]*(?<!\.git)\z/
+=======
+def default_regex
+  %r{\A[.?]?[a-zA-Z0-9][a-zA-Z0-9_\-\.]*(?<!\.git)\z}
+>>>>>>> files/ruby/regex.rb
+end
+FILE
+      end
+
+      let(:conflict_file) { Gitlab::Conflict::File.new({ data: file }, conflict, merge_request: merge_request) }
+      let(:sections) { conflict_file.sections }
+
+      it 'sets the correct match line headers' do
+        expect(sections[0][:lines].first).to have_attributes(type: 'match', text: '@@ -3,14 +3,14 @@')
+        expect(sections[3][:lines].first).to have_attributes(type: 'match', text: '@@ -19,26 +19,26 @@ def path_regexp')
+        expect(sections[6][:lines].first).to have_attributes(type: 'match', text: '@@ -47,52 +47,52 @@ end')
+      end
+
+      it 'does not add match lines where they are not needed' do
+        expect(sections[1][:lines].first.type).not_to eq('match')
+        expect(sections[2][:lines].first.type).not_to eq('match')
+        expect(sections[4][:lines].first.type).not_to eq('match')
+        expect(sections[5][:lines].first.type).not_to eq('match')
+        expect(sections[7][:lines].first.type).not_to eq('match')
+      end
+
+      it 'creates context sections of the correct length' do
+        expect(sections[0][:lines].reject(&:type).length).to eq(3)
+        expect(sections[2][:lines].reject(&:type).length).to eq(3)
+        expect(sections[3][:lines].reject(&:type).length).to eq(3)
+        expect(sections[5][:lines].reject(&:type).length).to eq(3)
+        expect(sections[6][:lines].reject(&:type).length).to eq(3)
+        expect(sections[8][:lines].reject(&:type).length).to eq(1)
+      end
+    end
   end
 
   describe '#as_json' do

From b79378cae8067d6c967770c0a3129e7a9999cc2f Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Fri, 5 Aug 2016 16:26:53 +0100
Subject: [PATCH 58/90] Add merge conflict docs

---
 .../merge_requests/img/conflict_section.png   | Bin 0 -> 247537 bytes
 .../img/merge_request_widget.png              | Bin 0 -> 32292 bytes
 .../merge_requests/resolve_conflicts.md       |  37 ++++++++++++++++++
 3 files changed, 37 insertions(+)
 create mode 100644 doc/user/project/merge_requests/img/conflict_section.png
 create mode 100644 doc/user/project/merge_requests/img/merge_request_widget.png
 create mode 100644 doc/user/project/merge_requests/resolve_conflicts.md

diff --git a/doc/user/project/merge_requests/img/conflict_section.png b/doc/user/project/merge_requests/img/conflict_section.png
new file mode 100644
index 0000000000000000000000000000000000000000..842e50b14b2c6646139e7d92ccb68b39a7610787
GIT binary patch
literal 247537
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%0A|01iHb=#(G)t?i82x
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
H>)-n?1pHJn

literal 0
HcmV?d00001

diff --git a/doc/user/project/merge_requests/img/merge_request_widget.png b/doc/user/project/merge_requests/img/merge_request_widget.png
new file mode 100644
index 0000000000000000000000000000000000000000..ffb96b17b0740373838cea9d446435977d443147
GIT binary patch
literal 32292
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
bCmi{lx|!J*Gs5C;k49N3#gFA5jC}tW8~pjY

literal 0
HcmV?d00001

diff --git a/doc/user/project/merge_requests/resolve_conflicts.md b/doc/user/project/merge_requests/resolve_conflicts.md
new file mode 100644
index 00000000000..b355d1a01f1
--- /dev/null
+++ b/doc/user/project/merge_requests/resolve_conflicts.md
@@ -0,0 +1,37 @@
+# Merge conflict resolution
+
+When a merge request has conflicts, GitLab may provide the option to resolve
+those conflicts in the GitLab UI. (See
+[conflicts available for resolution](#conflicts-available-for-resolution) for
+more information on when this is available.) If this is an option, you will see
+a **resolve these conflicts** link in the merge request widget:
+
+![Merge request widget](img/merge_request_widget.png)
+
+Clicking this will show a list of files with conflicts, with conflict sections
+highlighted:
+
+![Conflict section](img/conflict_section.png)
+
+Once all conflicts have been marked as using 'ours' or 'theirs', the conflict
+can be resolved. This will perform a merge of the target branch of the merge
+request into the source branch, resolving the conflicts using the options
+chosen. If the source branch is `feature` and the target branch is `master`,
+this is similar to performing `git checkout feature; git merge master` locally.
+
+## Conflicts available for resolution
+
+GitLab allows resolving conflicts in a file where all of the below are true:
+
+- The file is text, not binary
+- The file does not already contain conflict markers
+- The file, with conflict markers added, is not over 200 KB in size
+- The file exists under the same path in both branches
+
+If any file with conflicts in that merge request does not meet all of these
+criteria, the conflicts for that merge request cannot be resolved in the UI.
+
+Additionally, GitLab does not detect conflicts in renames away from a path. For
+example, this will not create a conflict: on branch `a`, doing `git mv file1
+file2`; on branch `b`, doing `git mv file1 file3`. Instead, both files will be
+present in the branch after the merge request is merged.

From 41f7cee99149f98f82afbe54587a4d2853f1ddc6 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 8 Aug 2016 13:26:09 +0300
Subject: [PATCH 59/90] Show loading button while Ajax request is in progress.

---
 .../merge_conflict_data_provider.js.es6       |  6 ++--
 .../merge_conflict_resolver.js.es6            | 33 ++++++++++++-------
 .../stylesheets/pages/merge_conflicts.scss    |  4 +++
 .../merge_requests/conflicts.html.haml        | 10 +++---
 4 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index f0f51a65b94..7e20eb1ce66 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -11,6 +11,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
       hasError       : false,
       isParallel     : diffViewType === 'parallel',
       diffViewType   : diffViewType,
+      isSubmitting   : false,
       conflictsData  : {},
       resolutionData : {}
     }
@@ -18,7 +19,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
 
   decorateData(vueInstance, data) {
-    this.vueInstance    = vueInstance;
+    this.vueInstance = vueInstance;
 
     if (data.type === 'error') {
       vueInstance.hasError = true;
@@ -34,6 +35,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
     }
 
     vueInstance.conflictsData = data;
+    vueInstance.isSubmitting = false;
   }
 
 
@@ -233,7 +235,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
 
   isAllResolved() {
-    return this.getConflictsCount() === this.getResolvedCount();
+    return !this.vueInstance.isSubmitting && this.getConflictsCount() === this.getResolvedCount();
   }
 
 
diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index cff43a3b40f..59e26f1405a 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -31,6 +31,17 @@ window.MergeConflictResolver = class MergeConflictResolver {
   }
 
 
+  setComputedProperties() {
+    const dp = this.dataProvider;
+
+    return {
+      conflictsCount() { return dp.getConflictsCount() },
+      resolvedCount()  { return dp.getResolvedCount() },
+      allResolved()    { return dp.isAllResolved() }
+    }
+  }
+
+
   fetchData() {
     const dp = this.dataProvider;
 
@@ -47,21 +58,19 @@ window.MergeConflictResolver = class MergeConflictResolver {
   }
 
 
-  setComputedProperties() {
-    const dp = this.dataProvider;
-
-    return {
-      conflictsCount() { return dp.getConflictsCount() },
-      resolvedCount()  { return dp.getResolvedCount() },
-      allResolved()    { return dp.isAllResolved() }
-    }
-  }
-
   commit() {
+    this.vue.isSubmitting = true;
+
     $.post('./resolve_conflicts', this.dataProvider.getCommitData())
-      .then( (data) => {
-        window.location.href = data.redirect_to
+      .done( (data) => {
+        window.location.href = data.redirect_to;
       })
+      .error(() => {
+        new Flash('Something went wrong!');
+      })
+      .always(() => {
+        this.vue.isSubmitting = false;
+      });
   }
 
 }
diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index 965348b3b88..ab5a2570827 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -137,4 +137,8 @@ $unselected_line:         #f8f8f8;
       outline: none;
     }
   }
+
+  .btn-success .fa-spinner {
+    color: #FFF;
+  }
 }
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index 14252fd3256..46e85187a42 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -126,8 +126,10 @@
         %textarea.form-control.js-commit-message{":disabled" => "!allResolved", "v-model" => "conflictsData.commitMessage"}
           {{{conflictsData.commitMessage}}}
 
-      %button{type: 'button', class: 'btn btn-success js-submit-button', ":disabled" => "!allResolved", "@click" => "commit()"}
-        Commit conflict resolution
+      %button{type: "button", class: "btn btn-success js-submit-button", ":disabled" => "!allResolved", "@click" => "commit()"}
+        %span Commit conflict resolution
+        %a.fa.fa-spin.fa-spinner{":class" => "{'hidden': !isSubmitting}"}
 
-      / %button{type: 'button', class: 'btn btn-cancel'}
-      /   Cancel
+      / FIXME: Hardcoded path
+      %a.btn.btn-cancel{"href" => "diffs"}
+        Cancel

From 0039fcd3ff8cb7f9bb103d734942c3900994f7e6 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 8 Aug 2016 15:57:09 +0300
Subject: [PATCH 60/90] Update button titles in merge conflicts widget header.

---
 .../javascripts/merge_conflict_data_provider.js.es6      | 9 +++++++--
 app/views/projects/merge_requests/conflicts.html.haml    | 6 ++++--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 7e20eb1ce66..5b46dabe431 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -1,5 +1,8 @@
-const HEAD_HEADER_TEXT   = 'HEAD//our changes';
-const ORIGIN_HEADER_TEXT = 'origin//their changes';
+const HEAD_HEADER_TEXT    = 'HEAD//our changes';
+const ORIGIN_HEADER_TEXT  = 'origin//their changes';
+
+const HEAD_BUTTON_TITLE   = 'Use ours';
+const ORIGIN_BUTTON_TITLE = 'Use theirs';
 
 window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
@@ -275,6 +278,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
     return {
       id          : id,
       richText    : HEAD_HEADER_TEXT,
+      buttonTitle : HEAD_BUTTON_TITLE,
       type        : 'new',
       section     : 'head',
       isHeader    : true,
@@ -289,6 +293,7 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
     return {
       id          : id,
       richText    : ORIGIN_HEADER_TEXT,
+      buttonTitle : ORIGIN_BUTTON_TITLE,
       type        : 'old',
       section     : 'origin',
       isHeader    : true,
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index 46e85187a42..e04c06ff574 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -62,7 +62,8 @@
                       'selected': line.isSelected, |
                       'unselected': line.isUnselected}"}
                       %strong {{line.richText}}
-                      %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
+                      %button.btn{"@click" => "handleSelected(line.id, line.section)"}
+                        {{line.buttonTitle}}
 
                   %template{"v-if" => "!line.isHeader"}
                     %td.diff-line-num.old_line{":class" => "{ |
@@ -113,7 +114,8 @@
                   %td.diff-line-num.header
                   %td.line_content.header
                     %strong {{{line.richText}}}
-                    %button.btn{"@click" => "handleSelected(line.id, line.section)"} Use this
+                    %button.btn{"@click" => "handleSelected(line.id, line.section)"}
+                      {{line.buttonTitle}}
 
     .content-block.oneline-block.files-changed
       %strong.resolved-count {{resolvedCount}}

From 1def35100dc80e4c4a66db264ff10aa0df20be7c Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 8 Aug 2016 17:24:13 +0300
Subject: [PATCH 61/90] Update container fludity class if diff view mode is
 parallel.

---
 app/assets/javascripts/merge_conflict_resolver.js.es6 | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index 59e26f1405a..b1d376da7d5 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -54,6 +54,9 @@ window.MergeConflictResolver = class MergeConflictResolver {
       })
       .always( () => {
         this.vue.isLoading = false;
+        if (this.vue.diffViewType === 'parallel') {
+          $('.content-wrapper .container-fluid').removeClass('container-limited');
+        }
       })
   }
 

From f9e0a6dade443429116b32517c8b39daff2ba157 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 8 Aug 2016 17:24:52 +0300
Subject: [PATCH 62/90] Dynamically highlight code blocks in merge conflicts
 widgets.

---
 .../javascripts/merge_conflict_resolver.js.es6      | 13 +++++++++----
 .../projects/merge_requests/conflicts.html.haml     |  2 +-
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index b1d376da7d5..ed12b2fea82 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -46,14 +46,19 @@ window.MergeConflictResolver = class MergeConflictResolver {
     const dp = this.dataProvider;
 
     $.get('./conflicts.json')
-      .done( (data) => {
+      .done((data) => {
         dp.decorateData(this.vue, data);
       })
-      .error( (data) => {
+      .error((data) => {
         dp.handleFailedRequest(this.vue, data);
       })
-      .always( () => {
+      .always(() => {
         this.vue.isLoading = false;
+
+        this.vue.$nextTick(() => {
+          $('#conflicts .js-syntax-highlight').syntaxHighlight();
+        });
+
         if (this.vue.diffViewType === 'parallel') {
           $('.content-wrapper .container-fluid').removeClass('container-limited');
         }
@@ -65,7 +70,7 @@ window.MergeConflictResolver = class MergeConflictResolver {
     this.vue.isSubmitting = true;
 
     $.post('./resolve_conflicts', this.dataProvider.getCommitData())
-      .done( (data) => {
+      .done((data) => {
         window.location.href = data.redirect_to;
       })
       .error(() => {
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index e04c06ff574..81c87afb98d 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -45,7 +45,7 @@
             %a.btn.view-file.btn-file-option{":href" => "file.blobPath"}
               View file @{{conflictsData.shortCommitSha}}
         .diff-content.diff-wrap-lines
-          .diff-wrap-lines.code.file-content.js-syntax-highlight.white
+          .diff-wrap-lines.code.file-content.js-syntax-highlight
             %table
               %tr.line_holder.parallel{"v-for" => "section in file.parallelLines"}
                 %template{"v-for" => "line in section"}

From 709c308e0edf84d80dd3b103d34444a845b4c0ba Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 8 Aug 2016 21:33:59 +0300
Subject: [PATCH 63/90] Simplify Haml template and Scss files for MC UI.

---
 .../stylesheets/pages/merge_conflicts.scss    | 62 +------------------
 .../merge_requests/conflicts.html.haml        | 59 +++++++-----------
 2 files changed, 24 insertions(+), 97 deletions(-)

diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index ab5a2570827..fe116311fff 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -19,7 +19,6 @@ $unselected_line:         #f8f8f8;
     min-height: 19px;
   }
 
-
   .header.line_content, .diff-line-num {
     &.origin {
       background-color: $origin_gutter;
@@ -62,65 +61,6 @@ $unselected_line:         #f8f8f8;
     }
   }
 
-
-  .head {
-    .header, .diff-line-num {
-      background-color: $head_gutter;
-    }
-
-    td {
-      background-color: $head_line;
-    }
-
-    &.selected {
-      .header, .diff-line-num {
-        background-color: $selected_head_gutter;
-      }
-
-      td {
-        background-color: $selected_head_line;
-      }
-    }
-  }
-
-  .origin {
-    .header, .diff-line-num {
-      background-color: $origin_gutter;
-    }
-
-    td {
-      background-color: $origin_line;
-    }
-
-    &.selected {
-      .header, .diff-line-num {
-        background-color: $selected_origin_gutter;
-      }
-
-      td {
-        background-color: $selected_origin_line;
-      }
-    }
-  }
-
-  .origin, .head {
-    &.unselected {
-      .header, .diff-line-num {
-        background-color: $unselected_gutter;
-      }
-
-      td {
-        background-color: $unselected_line;
-      }
-    }
-  }
-
-  .parallel .header {
-    button {
-      right: 10px;
-    }
-  }
-
   .line_content.header {
     position: relative;
 
@@ -130,7 +70,7 @@ $unselected_line:         #f8f8f8;
       background: #fff;
       font-size: 10px;
       position: absolute;
-      right: 20px;
+      right: 10px;
       height: 17px;
       line-height: 4px; // FIXME: 4px?
       top: 1px;
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index 81c87afb98d..04233c6210f 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -7,6 +7,14 @@
 
 = render 'shared/issuable/sidebar', issuable: @merge_request
 
+
+- class_bindings = "{ |
+    'head': line.isHead, |
+    'origin': line.isOrigin, |
+    'match': line.hasMatch, |
+    'selected': line.isSelected, |
+    'unselected': line.isUnselected }"
+
 #conflicts{"v-cloak" => "true"}
   .loading{"v-if" => "isLoading"}
     %i.fa.fa-spinner.fa-spin
@@ -35,6 +43,7 @@
         into
         %strong {{conflictsData.target_branch}}
 
+
   .files-wrapper{"v-if" => "!isLoading && !hasError"}
     .files{"v-show" => "isParallel"}
       .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
@@ -51,36 +60,19 @@
                 %template{"v-for" => "line in section"}
 
                   %template{"v-if" => "line.isHeader"}
-                    %td.diff-line-num.header{":class" => "{ |
-                      'head': line.isHead, |
-                      'origin': line.isOrigin, |
-                      'selected': line.isSelected, |
-                      'unselected': line.isUnselected}"}
-                    %td.line_content.header{":class" => "{ |
-                      'head': line.isHead, |
-                      'origin': line.isOrigin, |
-                      'selected': line.isSelected, |
-                      'unselected': line.isUnselected}"}
+                    %td.diff-line-num.header{":class" => "#{class_bindings}"}
+                    %td.line_content.header{":class" => "#{class_bindings}"}
                       %strong {{line.richText}}
                       %button.btn{"@click" => "handleSelected(line.id, line.section)"}
                         {{line.buttonTitle}}
 
                   %template{"v-if" => "!line.isHeader"}
-                    %td.diff-line-num.old_line{":class" => "{ |
-                      'head': line.isHead, |
-                      'origin': line.isOrigin, |
-                      'match': line.hasMatch, |
-                      'selected': line.isSelected, |
-                      'unselected': line.isUnselected }"}
+                    %td.diff-line-num.old_line{":class" => "#{class_bindings}"}
                       {{line.lineNumber}}
-                    %td.line_content.parallel{":class" => "{ |
-                      'head': line.isHead, |
-                      'origin': line.isOrigin, |
-                      'match': line.hasMatch, |
-                      'selected': line.isSelected, |
-                      'unselected': line.isUnselected }"}
+                    %td.line_content.parallel{":class" => "#{class_bindings}"}
                       {{{line.richText}}}
 
+
     .files{"v-show" => "!isParallel"}
       .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}
         .file-title
@@ -91,32 +83,27 @@
               View file @{{conflictsData.shortCommitSha}}
 
         .diff-content.diff-wrap-lines
-          .diff-wrap-lines.code.file-content.js-syntax-highlight.white
+          .diff-wrap-lines.code.file-content.js-syntax-highlight
             %table
-              %tr.line_holder{"v-for" => "line in file.inlineLines", |
-                ":class" => "{ |
-                  'head': line.isHead, |
-                  'origin': line.isOrigin, |
-                  'match': line.hasMatch, |
-                  'selected': line.isSelected, |
-                  'unselected': line.isUnselected }"}
+              %tr.line_holder.diff-inline{"v-for" => "line in file.inlineLines"}
 
                 %template{"v-if" => "!line.isHeader"}
-                  %td.diff-line-num.new_line
+                  %td.diff-line-num.new_line{":class" => "#{class_bindings}"}
                     %a {{line.new_line}}
-                  %td.diff-line-num.old_line
+                  %td.diff-line-num.old_line{":class" => "#{class_bindings}"}
                     %a {{line.old_line}}
-                  %td.line_content
+                  %td.line_content{":class" => "#{class_bindings}"}
                     {{{line.richText}}}
 
                 %template{"v-if" => "line.isHeader"}
-                  %td.diff-line-num.header
-                  %td.diff-line-num.header
-                  %td.line_content.header
+                  %td.diff-line-num.header{":class" => "#{class_bindings}"}
+                  %td.diff-line-num.header{":class" => "#{class_bindings}"}
+                  %td.line_content.header{":class" => "#{class_bindings}"}
                     %strong {{{line.richText}}}
                     %button.btn{"@click" => "handleSelected(line.id, line.section)"}
                       {{line.buttonTitle}}
 
+
     .content-block.oneline-block.files-changed
       %strong.resolved-count {{resolvedCount}}
       of

From bdbff152988aa5a21c121a6113fe608fc89818b8 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Mon, 8 Aug 2016 22:46:00 +0300
Subject: [PATCH 64/90] Separate inline haml vue templates into new files.

---
 .../merge_requests/conflicts.html.haml        | 120 ++----------------
 .../conflicts/_commit_stats.html.haml         |  20 +++
 .../conflicts/_inline_view.html.haml          |  29 +++++
 .../conflicts/_parallel_view.html.haml        |  26 ++++
 .../conflicts/_submit_form.html.haml          |  18 +++
 5 files changed, 105 insertions(+), 108 deletions(-)
 create mode 100644 app/views/projects/merge_requests/conflicts/_commit_stats.html.haml
 create mode 100644 app/views/projects/merge_requests/conflicts/_inline_view.html.haml
 create mode 100644 app/views/projects/merge_requests/conflicts/_parallel_view.html.haml
 create mode 100644 app/views/projects/merge_requests/conflicts/_submit_form.html.haml

diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index 04233c6210f..6eda9bb3f65 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -1,13 +1,3 @@
-- page_title "Merge Conflicts", "#{@merge_request.title} (#{@merge_request.to_reference}", "Merge Requests"
-
-= render "projects/merge_requests/show/mr_title"
-
-.merge-request-details.issuable-details
-  = render "projects/merge_requests/show/mr_box"
-
-= render 'shared/issuable/sidebar', issuable: @merge_request
-
-
 - class_bindings = "{ |
     'head': line.isHead, |
     'origin': line.isOrigin, |
@@ -15,6 +5,14 @@
     'selected': line.isSelected, |
     'unselected': line.isUnselected }"
 
+- page_title "Merge Conflicts", "#{@merge_request.title} (#{@merge_request.to_reference}", "Merge Requests"
+= render "projects/merge_requests/show/mr_title"
+
+.merge-request-details.issuable-details
+  = render "projects/merge_requests/show/mr_box"
+
+= render 'shared/issuable/sidebar', issuable: @merge_request
+
 #conflicts{"v-cloak" => "true"}
   .loading{"v-if" => "isLoading"}
     %i.fa.fa-spinner.fa-spin
@@ -22,103 +20,9 @@
   .content-block.oneline-block{"v-if" => "hasError"}
     %p {{conflictsData.errorMessage}}
 
-  .content-block.oneline-block.files-changed{"v-if" => "!isLoading && !hasError"}
-    .inline-parallel-buttons
-      .btn-group
-        %a.btn{ |
-          ":class" => "{'active': !isParallel}", |
-          "@click" => "handleViewTypeChange('inline')"}
-          Inline
-        %a.btn{ |
-          ":class" => "{'active': isParallel}", |
-          "@click" => "handleViewTypeChange('parallel')"}
-          Side-by-side
-
-    .js-toggle-container
-      .commit-stat-summary
-        Showing
-        %strong.cred {{conflictsCount}} conflicts
-        for
-        %strong {{conflictsData.source_branch}}
-        into
-        %strong {{conflictsData.target_branch}}
-
+  = render partial: "projects/merge_requests/conflicts/commit_stats.html.haml"
 
   .files-wrapper{"v-if" => "!isLoading && !hasError"}
-    .files{"v-show" => "isParallel"}
-      .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
-        .file-title
-          %i.fa.fa-fw.fa{":class" => "file.iconClass"}
-          %strong {{file.filePath}}
-          .file-actions
-            %a.btn.view-file.btn-file-option{":href" => "file.blobPath"}
-              View file @{{conflictsData.shortCommitSha}}
-        .diff-content.diff-wrap-lines
-          .diff-wrap-lines.code.file-content.js-syntax-highlight
-            %table
-              %tr.line_holder.parallel{"v-for" => "section in file.parallelLines"}
-                %template{"v-for" => "line in section"}
-
-                  %template{"v-if" => "line.isHeader"}
-                    %td.diff-line-num.header{":class" => "#{class_bindings}"}
-                    %td.line_content.header{":class" => "#{class_bindings}"}
-                      %strong {{line.richText}}
-                      %button.btn{"@click" => "handleSelected(line.id, line.section)"}
-                        {{line.buttonTitle}}
-
-                  %template{"v-if" => "!line.isHeader"}
-                    %td.diff-line-num.old_line{":class" => "#{class_bindings}"}
-                      {{line.lineNumber}}
-                    %td.line_content.parallel{":class" => "#{class_bindings}"}
-                      {{{line.richText}}}
-
-
-    .files{"v-show" => "!isParallel"}
-      .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}
-        .file-title
-          %i.fa.fa-fw{":class" => "file.iconClass"}
-          %strong {{file.filePath}}
-          .file-actions
-            %a.btn.view-file.btn-file-option{":href" => "file.blobPath"}
-              View file @{{conflictsData.shortCommitSha}}
-
-        .diff-content.diff-wrap-lines
-          .diff-wrap-lines.code.file-content.js-syntax-highlight
-            %table
-              %tr.line_holder.diff-inline{"v-for" => "line in file.inlineLines"}
-
-                %template{"v-if" => "!line.isHeader"}
-                  %td.diff-line-num.new_line{":class" => "#{class_bindings}"}
-                    %a {{line.new_line}}
-                  %td.diff-line-num.old_line{":class" => "#{class_bindings}"}
-                    %a {{line.old_line}}
-                  %td.line_content{":class" => "#{class_bindings}"}
-                    {{{line.richText}}}
-
-                %template{"v-if" => "line.isHeader"}
-                  %td.diff-line-num.header{":class" => "#{class_bindings}"}
-                  %td.diff-line-num.header{":class" => "#{class_bindings}"}
-                  %td.line_content.header{":class" => "#{class_bindings}"}
-                    %strong {{{line.richText}}}
-                    %button.btn{"@click" => "handleSelected(line.id, line.section)"}
-                      {{line.buttonTitle}}
-
-
-    .content-block.oneline-block.files-changed
-      %strong.resolved-count {{resolvedCount}}
-      of
-      %strong.total-count {{conflictsCount}}
-      conflicts have been resolved
-
-      .commit-message-container.form-group
-        .max-width-marker
-        %textarea.form-control.js-commit-message{":disabled" => "!allResolved", "v-model" => "conflictsData.commitMessage"}
-          {{{conflictsData.commitMessage}}}
-
-      %button{type: "button", class: "btn btn-success js-submit-button", ":disabled" => "!allResolved", "@click" => "commit()"}
-        %span Commit conflict resolution
-        %a.fa.fa-spin.fa-spinner{":class" => "{'hidden': !isSubmitting}"}
-
-      / FIXME: Hardcoded path
-      %a.btn.btn-cancel{"href" => "diffs"}
-        Cancel
+    = render partial: "projects/merge_requests/conflicts/parallel_view.html.haml", locals: { class_bindings: class_bindings }
+    = render partial: "projects/merge_requests/conflicts/inline_view.html.haml", locals: { class_bindings: class_bindings }
+    = render partial: "projects/merge_requests/conflicts/submit_form.html.haml"
diff --git a/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml b/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml
new file mode 100644
index 00000000000..8c7f67370e4
--- /dev/null
+++ b/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml
@@ -0,0 +1,20 @@
+.content-block.oneline-block.files-changed{"v-if" => "!isLoading && !hasError"}
+  .inline-parallel-buttons
+    .btn-group
+      %a.btn{ |
+        ":class" => "{'active': !isParallel}", |
+        "@click" => "handleViewTypeChange('inline')"}
+        Inline
+      %a.btn{ |
+        ":class" => "{'active': isParallel}", |
+        "@click" => "handleViewTypeChange('parallel')"}
+        Side-by-side
+
+  .js-toggle-container
+    .commit-stat-summary
+      Showing
+      %strong.cred {{conflictsCount}} conflicts
+      for
+      %strong {{conflictsData.source_branch}}
+      into
+      %strong {{conflictsData.target_branch}}
diff --git a/app/views/projects/merge_requests/conflicts/_inline_view.html.haml b/app/views/projects/merge_requests/conflicts/_inline_view.html.haml
new file mode 100644
index 00000000000..46141281ed6
--- /dev/null
+++ b/app/views/projects/merge_requests/conflicts/_inline_view.html.haml
@@ -0,0 +1,29 @@
+.files{"v-show" => "!isParallel"}
+  .diff-file.file-holder.conflict.inline-view{"v-for" => "file in conflictsData.files"}
+    .file-title
+      %i.fa.fa-fw{":class" => "file.iconClass"}
+      %strong {{file.filePath}}
+      .file-actions
+        %a.btn.view-file.btn-file-option{":href" => "file.blobPath"}
+          View file @{{conflictsData.shortCommitSha}}
+
+    .diff-content.diff-wrap-lines
+      .diff-wrap-lines.code.file-content.js-syntax-highlight
+        %table
+          %tr.line_holder.diff-inline{"v-for" => "line in file.inlineLines"}
+
+            %template{"v-if" => "!line.isHeader"}
+              %td.diff-line-num.new_line{":class" => "#{class_bindings}"}
+                %a {{line.new_line}}
+              %td.diff-line-num.old_line{":class" => "#{class_bindings}"}
+                %a {{line.old_line}}
+              %td.line_content{":class" => "#{class_bindings}"}
+                {{{line.richText}}}
+
+            %template{"v-if" => "line.isHeader"}
+              %td.diff-line-num.header{":class" => "#{class_bindings}"}
+              %td.diff-line-num.header{":class" => "#{class_bindings}"}
+              %td.line_content.header{":class" => "#{class_bindings}"}
+                %strong {{{line.richText}}}
+                %button.btn{"@click" => "handleSelected(line.id, line.section)"}
+                  {{line.buttonTitle}}
diff --git a/app/views/projects/merge_requests/conflicts/_parallel_view.html.haml b/app/views/projects/merge_requests/conflicts/_parallel_view.html.haml
new file mode 100644
index 00000000000..cabe4751690
--- /dev/null
+++ b/app/views/projects/merge_requests/conflicts/_parallel_view.html.haml
@@ -0,0 +1,26 @@
+.files{"v-show" => "isParallel"}
+  .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
+    .file-title
+      %i.fa.fa-fw.fa{":class" => "file.iconClass"}
+      %strong {{file.filePath}}
+      .file-actions
+        %a.btn.view-file.btn-file-option{":href" => "file.blobPath"}
+          View file @{{conflictsData.shortCommitSha}}
+    .diff-content.diff-wrap-lines
+      .diff-wrap-lines.code.file-content.js-syntax-highlight
+        %table
+          %tr.line_holder.parallel{"v-for" => "section in file.parallelLines"}
+            %template{"v-for" => "line in section"}
+
+              %template{"v-if" => "line.isHeader"}
+                %td.diff-line-num.header{":class" => "#{class_bindings}"}
+                %td.line_content.header{":class" => "#{class_bindings}"}
+                  %strong {{line.richText}}
+                  %button.btn{"@click" => "handleSelected(line.id, line.section)"}
+                    {{line.buttonTitle}}
+
+              %template{"v-if" => "!line.isHeader"}
+                %td.diff-line-num.old_line{":class" => "#{class_bindings}"}
+                  {{line.lineNumber}}
+                %td.line_content.parallel{":class" => "#{class_bindings}"}
+                  {{{line.richText}}}
diff --git a/app/views/projects/merge_requests/conflicts/_submit_form.html.haml b/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
new file mode 100644
index 00000000000..5811fe739d3
--- /dev/null
+++ b/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
@@ -0,0 +1,18 @@
+.content-block.oneline-block.files-changed
+  %strong.resolved-count {{resolvedCount}}
+  of
+  %strong.total-count {{conflictsCount}}
+  conflicts have been resolved
+
+  .commit-message-container.form-group
+    .max-width-marker
+    %textarea.form-control.js-commit-message{":disabled" => "!allResolved", "v-model" => "conflictsData.commitMessage"}
+      {{{conflictsData.commitMessage}}}
+
+  %button{type: "button", class: "btn btn-success js-submit-button", ":disabled" => "!allResolved", "@click" => "commit()"}
+    %span Commit conflict resolution
+    %a.fa.fa-spin.fa-spinner{":class" => "{'hidden': !isSubmitting}"}
+
+  / FIXME: Hardcoded path
+  %a.btn.btn-cancel{"href" => "diffs"}
+    Cancel

From c6c74a37d9f41d7083bc4ecdf06b75222cf89b46 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Tue, 9 Aug 2016 00:39:07 +0300
Subject: [PATCH 65/90] Implement color schemes for MC UI.

---
 .../stylesheets/pages/merge_conflicts.scss    | 378 +++++++++++++++---
 1 file changed, 326 insertions(+), 52 deletions(-)

diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index fe116311fff..80d26d4d2b1 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -1,66 +1,340 @@
-$head_line:               #effdeb;
-$head_gutter:             #daface;
-$selected_head_gutter:    #b2ee9e;
-$selected_head_line:      #d4f5c9;
+$white_header_head_neutral   : #e1fad7;
+$white_line_head_neutral     : #effdec;
+$white_button_head_neutral   : #9ADB84;
 
-$origin_line:             #f2f9ff;
-$origin_gutter:           #e0f0ff;
-$selected_origin_gutter:  #a3d3ff;
-$selected_origin_line:    #cee4f9;
+$white_header_head_chosen    : #baf0a8;
+$white_line_head_chosen      : #e1fad7;
+$white_button_head_chosen    : #52C22D;
+
+$white_header_origin_neutral : #e0f0ff;
+$white_line_origin_neutral   : #f2f9ff;
+$white_button_origin_neutral : #87C2FA;
+
+$white_header_origin_chosen  : #add8ff;
+$white_line_origin_chosen    : #e0f0ff;
+$white_button_origin_chosen  : #268CED;
+
+$white_header_not_chosen     : #F0F0F0;
+$white_line_not_chosen       : #f9f9f9;
+
+
+
+$dark_header_head_neutral   : rgba(#33FF33, .2);
+$dark_line_head_neutral     : rgba(#33FF33, .1);
+$dark_button_head_neutral   : #40874F;
+
+$dark_header_head_chosen    : rgba(#33FF33, .33);
+$dark_line_head_chosen      : rgba(#33FF33, .2);
+$dark_button_head_chosen    : #258537;
+
+$dark_header_origin_neutral : rgba(#2878c9, .4);
+$dark_line_origin_neutral   : rgba(#2878c9, .3);
+$dark_button_origin_neutral : #2a5c8c;
+
+$dark_header_origin_chosen  : rgba(#2878c9, .6);
+$dark_line_origin_chosen    : rgba(#2878c9, .4);
+$dark_button_origin_chosen  : #1d6cbf;
+
+$dark_header_not_chosen     : rgba(#FFF, .25);
+$dark_line_not_chosen       : rgba(#FFF, .1);
+
+
+
+$solarized_light_header_head_neutral   : rgba(#859900, .37);
+$solarized_light_line_head_neutral     : rgba(#859900, .2);
+$solarized_light_button_head_neutral   : #afb262;
+
+$solarized_light_header_head_chosen    : rgba(#859900, .5);
+$solarized_light_line_head_chosen      : rgba(#859900, .37);
+$solarized_light_button_head_chosen    : #94993d;
+
+$solarized_light_header_origin_neutral : rgba(#2878C9, .37);
+$solarized_light_line_origin_neutral   : rgba(#2878C9, .15);
+$solarized_light_button_origin_neutral : #60A1BF;
+
+$solarized_light_header_origin_chosen  : rgba(#2878C9, .6);
+$solarized_light_line_origin_chosen    : rgba(#2878C9, .37);
+$solarized_light_button_origin_chosen  : #2482b2;
+
+$solarized_light_header_not_chosen     : rgba(#FFF, .37);
+$solarized_light_line_not_chosen       : rgba(#FFF, .2);
+
+
+
+$solarized_dark_header_head_neutral   : rgba(#859900, .35);
+$solarized_dark_line_head_neutral     : rgba(#859900, .15);
+$solarized_dark_button_head_neutral   : #376b20;
+
+$solarized_dark_header_head_chosen    : rgba(#859900, .5);
+$solarized_dark_line_head_chosen      : rgba(#859900, .35);
+$solarized_dark_button_head_chosen    : #39800d;
+
+$solarized_dark_header_origin_neutral : rgba(#2878C9, .35);
+$solarized_dark_line_origin_neutral   : rgba(#2878C9, .15);
+$solarized_dark_button_origin_neutral : #086799;
+
+$solarized_dark_header_origin_chosen  : rgba(#2878C9, .6);
+$solarized_dark_line_origin_chosen    : rgba(#2878C9, .35);
+$solarized_dark_button_origin_chosen  : #0082CC;
+
+$solarized_dark_header_not_chosen     : rgba(#FFF, .25);
+$solarized_dark_line_not_chosen       : rgba(#FFF, .15);
+
+
+
+$monokai_header_head_neutral   : rgba(#A6E22E, .25);
+$monokai_line_head_neutral     : rgba(#A6E22E, .1);
+$monokai_button_head_neutral   : #376b20;
+
+$monokai_header_head_chosen    : rgba(#A6E22E, .4);
+$monokai_line_head_chosen      : rgba(#A6E22E, .25);
+$monokai_button_head_chosen    : #39800d;
+
+$monokai_header_origin_neutral : rgba(#60D9F1, .35);
+$monokai_line_origin_neutral   : rgba(#60D9F1, .15);
+$monokai_button_origin_neutral : #38848C;
+
+$monokai_header_origin_chosen  : rgba(#60D9F1, .5);
+$monokai_line_origin_chosen    : rgba(#60D9F1, .35);
+$monokai_button_origin_chosen  : #3EA4B2;
+
+$monokai_header_not_chosen     : rgba(#FFF, .24);
+$monokai_line_not_chosen       : rgba(#FFF, .1);
 
-$unselected_gutter:       #eee;
-$unselected_line:         #f8f8f8;
 
 
 #conflicts {
 
+  .white {
+    .header.line_content, .diff-line-num {
+      &.origin {
+        background-color: $white_header_origin_neutral;
+        &.selected {
+          background-color: $white_header_origin_chosen;
+        }
+        &.unselected {
+          background-color: $white_header_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $white_header_head_neutral;
+        &.selected {
+          background-color: $white_header_head_chosen;
+        }
+        &.unselected {
+          background-color: $white_header_not_chosen;
+        }
+      }
+    }
+
+    .line_content {
+      &.origin {
+        background-color: $white_line_origin_neutral;
+        &.selected {
+          background-color: $white_line_origin_chosen;
+        }
+        &.unselected {
+          background-color: $white_line_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $white_line_head_neutral;
+        &.selected {
+          background-color: $white_line_head_chosen;
+        }
+        &.unselected {
+          background-color: $white_line_not_chosen;
+        }
+      }
+    }
+  }
+
+
+  .dark {
+    .header.line_content, .diff-line-num {
+      &.origin {
+        background-color: $dark_header_origin_neutral;
+        &.selected {
+          background-color: $dark_header_origin_chosen;
+        }
+        &.unselected {
+          background-color: $dark_header_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $dark_header_head_neutral;
+        &.selected {
+          background-color: $dark_header_head_chosen;
+        }
+        &.unselected {
+          background-color: $dark_header_not_chosen;
+        }
+      }
+    }
+
+    .line_content {
+      &.origin {
+        background-color: $dark_line_origin_neutral;
+        &.selected {
+          background-color: $dark_line_origin_chosen;
+        }
+        &.unselected {
+          background-color: $dark_line_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $dark_line_head_neutral;
+        &.selected {
+          background-color: $dark_line_head_chosen;
+        }
+        &.unselected {
+          background-color: $dark_line_not_chosen;
+        }
+      }
+    }
+  }
+
+
+  .solarized-light {
+    .header.line_content, .diff-line-num {
+      &.origin {
+        background-color: $solarized_light_header_origin_neutral;
+        &.selected {
+          background-color: $solarized_light_header_origin_chosen;
+        }
+        &.unselected {
+          background-color: $solarized_light_header_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $solarized_light_header_head_neutral;
+        &.selected {
+          background-color: $solarized_light_header_head_chosen;
+        }
+        &.unselected {
+          background-color: $solarized_light_header_not_chosen;
+        }
+      }
+    }
+
+    .line_content {
+      &.origin {
+        background-color: $solarized_light_line_origin_neutral;
+        &.selected {
+          background-color: $solarized_light_line_origin_chosen;
+        }
+        &.unselected {
+          background-color: $solarized_light_line_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $solarized_light_line_head_neutral;
+        &.selected {
+          background-color: $solarized_light_line_head_chosen;
+        }
+        &.unselected {
+          background-color: $solarized_light_line_not_chosen;
+        }
+      }
+    }
+  }
+
+
+  .solarized-dark {
+    .header.line_content, .diff-line-num {
+      &.origin {
+        background-color: $solarized_dark_header_origin_neutral;
+        &.selected {
+          background-color: $solarized_dark_header_origin_chosen;
+        }
+        &.unselected {
+          background-color: $solarized_dark_header_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $solarized_dark_header_head_neutral;
+        &.selected {
+          background-color: $solarized_dark_header_head_chosen;
+        }
+        &.unselected {
+          background-color: $solarized_dark_header_not_chosen;
+        }
+      }
+    }
+
+    .line_content {
+      &.origin {
+        background-color: $solarized_dark_line_origin_neutral;
+        &.selected {
+          background-color: $solarized_dark_line_origin_chosen;
+        }
+        &.unselected {
+          background-color: $solarized_dark_line_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $solarized_dark_line_head_neutral;
+        &.selected {
+          background-color: $solarized_dark_line_head_chosen;
+        }
+        &.unselected {
+          background-color: $solarized_dark_line_not_chosen;
+        }
+      }
+    }
+  }
+
+
+  .monokai {
+    .header.line_content, .diff-line-num {
+      &.origin {
+        background-color: $monokai_header_origin_neutral;
+        &.selected {
+          background-color: $monokai_header_origin_chosen;
+        }
+        &.unselected {
+          background-color: $monokai_header_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $monokai_header_head_neutral;
+        &.selected {
+          background-color: $monokai_header_head_chosen;
+        }
+        &.unselected {
+          background-color: $monokai_header_not_chosen;
+        }
+      }
+    }
+
+    .line_content {
+      &.origin {
+        background-color: $monokai_line_origin_neutral;
+        &.selected {
+          background-color: $monokai_line_origin_chosen;
+        }
+        &.unselected {
+          background-color: $monokai_line_not_chosen;
+        }
+      }
+      &.head {
+        background-color: $monokai_line_head_neutral;
+        &.selected {
+          background-color: $monokai_line_head_chosen;
+        }
+        &.unselected {
+          background-color: $monokai_line_not_chosen;
+        }
+      }
+    }
+  }
+
+
   .diff-wrap-lines .line_content {
     white-space: normal;
     min-height: 19px;
   }
 
-  .header.line_content, .diff-line-num {
-    &.origin {
-      background-color: $origin_gutter;
-      &.selected {
-        background-color: $selected_origin_gutter;
-      }
-      &.unselected {
-        background-color: $unselected_gutter;
-      }
-    }
-    &.head {
-      background-color: $head_gutter;
-      &.selected {
-        background-color: $selected_head_gutter;
-      }
-      &.unselected {
-        background-color: $unselected_gutter;
-      }
-    }
-  }
-
-  .line_content {
-    &.origin {
-      background-color: $origin_line;
-      &.selected {
-        background-color: $selected_origin_line;
-      }
-      &.unselected {
-        background-color: $unselected_line;
-      }
-    }
-    &.head {
-      background-color: $head_line;
-      &.selected {
-        background-color: $selected_head_line;
-      }
-      &.unselected {
-        background-color: $unselected_line;
-      }
-    }
-  }
-
   .line_content.header {
     position: relative;
 

From 7927484435a9dc814d3ffa6d9182beac4f672cbd Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Tue, 9 Aug 2016 00:51:04 +0300
Subject: [PATCH 66/90] Use mixin to create color schemes.

Some SCSS Foo in action! :boom:
---
 .../stylesheets/pages/merge_conflicts.scss    | 413 ++++++------------
 1 file changed, 125 insertions(+), 288 deletions(-)

diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index 80d26d4d2b1..af5f778cb7e 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -1,334 +1,171 @@
-$white_header_head_neutral   : #e1fad7;
-$white_line_head_neutral     : #effdec;
-$white_button_head_neutral   : #9ADB84;
+$colors: (
+  white_header_head_neutral   : #e1fad7,
+  white_line_head_neutral     : #effdec,
+  white_button_head_neutral   : #9ADB84,
 
-$white_header_head_chosen    : #baf0a8;
-$white_line_head_chosen      : #e1fad7;
-$white_button_head_chosen    : #52C22D;
+  white_header_head_chosen    : #baf0a8,
+  white_line_head_chosen      : #e1fad7,
+  white_button_head_chosen    : #52C22D,
 
-$white_header_origin_neutral : #e0f0ff;
-$white_line_origin_neutral   : #f2f9ff;
-$white_button_origin_neutral : #87C2FA;
+  white_header_origin_neutral : #e0f0ff,
+  white_line_origin_neutral   : #f2f9ff,
+  white_button_origin_neutral : #87C2FA,
 
-$white_header_origin_chosen  : #add8ff;
-$white_line_origin_chosen    : #e0f0ff;
-$white_button_origin_chosen  : #268CED;
+  white_header_origin_chosen  : #add8ff,
+  white_line_origin_chosen    : #e0f0ff,
+  white_button_origin_chosen  : #268CED,
 
-$white_header_not_chosen     : #F0F0F0;
-$white_line_not_chosen       : #f9f9f9;
+  white_header_not_chosen     : #F0F0F0,
+  white_line_not_chosen       : #f9f9f9,
 
 
+  dark_header_head_neutral   : rgba(#33FF33, .2),
+  dark_line_head_neutral     : rgba(#33FF33, .1),
+  dark_button_head_neutral   : #40874F,
 
-$dark_header_head_neutral   : rgba(#33FF33, .2);
-$dark_line_head_neutral     : rgba(#33FF33, .1);
-$dark_button_head_neutral   : #40874F;
+  dark_header_head_chosen    : rgba(#33FF33, .33),
+  dark_line_head_chosen      : rgba(#33FF33, .2),
+  dark_button_head_chosen    : #258537,
 
-$dark_header_head_chosen    : rgba(#33FF33, .33);
-$dark_line_head_chosen      : rgba(#33FF33, .2);
-$dark_button_head_chosen    : #258537;
+  dark_header_origin_neutral : rgba(#2878c9, .4),
+  dark_line_origin_neutral   : rgba(#2878c9, .3),
+  dark_button_origin_neutral : #2a5c8c,
 
-$dark_header_origin_neutral : rgba(#2878c9, .4);
-$dark_line_origin_neutral   : rgba(#2878c9, .3);
-$dark_button_origin_neutral : #2a5c8c;
+  dark_header_origin_chosen  : rgba(#2878c9, .6),
+  dark_line_origin_chosen    : rgba(#2878c9, .4),
+  dark_button_origin_chosen  : #1d6cbf,
 
-$dark_header_origin_chosen  : rgba(#2878c9, .6);
-$dark_line_origin_chosen    : rgba(#2878c9, .4);
-$dark_button_origin_chosen  : #1d6cbf;
-
-$dark_header_not_chosen     : rgba(#FFF, .25);
-$dark_line_not_chosen       : rgba(#FFF, .1);
+  dark_header_not_chosen     : rgba(#FFF, .25),
+  dark_line_not_chosen       : rgba(#FFF, .1),
 
 
+  monokai_header_head_neutral   : rgba(#A6E22E, .25),
+  monokai_line_head_neutral     : rgba(#A6E22E, .1),
+  monokai_button_head_neutral   : #376b20,
 
-$solarized_light_header_head_neutral   : rgba(#859900, .37);
-$solarized_light_line_head_neutral     : rgba(#859900, .2);
-$solarized_light_button_head_neutral   : #afb262;
+  monokai_header_head_chosen    : rgba(#A6E22E, .4),
+  monokai_line_head_chosen      : rgba(#A6E22E, .25),
+  monokai_button_head_chosen    : #39800d,
 
-$solarized_light_header_head_chosen    : rgba(#859900, .5);
-$solarized_light_line_head_chosen      : rgba(#859900, .37);
-$solarized_light_button_head_chosen    : #94993d;
+  monokai_header_origin_neutral : rgba(#60D9F1, .35),
+  monokai_line_origin_neutral   : rgba(#60D9F1, .15),
+  monokai_button_origin_neutral : #38848C,
 
-$solarized_light_header_origin_neutral : rgba(#2878C9, .37);
-$solarized_light_line_origin_neutral   : rgba(#2878C9, .15);
-$solarized_light_button_origin_neutral : #60A1BF;
+  monokai_header_origin_chosen  : rgba(#60D9F1, .5),
+  monokai_line_origin_chosen    : rgba(#60D9F1, .35),
+  monokai_button_origin_chosen  : #3EA4B2,
 
-$solarized_light_header_origin_chosen  : rgba(#2878C9, .6);
-$solarized_light_line_origin_chosen    : rgba(#2878C9, .37);
-$solarized_light_button_origin_chosen  : #2482b2;
-
-$solarized_light_header_not_chosen     : rgba(#FFF, .37);
-$solarized_light_line_not_chosen       : rgba(#FFF, .2);
+  monokai_header_not_chosen     : rgba(#FFF, .24),
+  monokai_line_not_chosen       : rgba(#FFF, .1),
 
 
+  solarized_light_header_head_neutral   : rgba(#859900, .37),
+  solarized_light_line_head_neutral     : rgba(#859900, .2),
+  solarized_light_button_head_neutral   : #afb262,
 
-$solarized_dark_header_head_neutral   : rgba(#859900, .35);
-$solarized_dark_line_head_neutral     : rgba(#859900, .15);
-$solarized_dark_button_head_neutral   : #376b20;
+  solarized_light_header_head_chosen    : rgba(#859900, .5),
+  solarized_light_line_head_chosen      : rgba(#859900, .37),
+  solarized_light_button_head_chosen    : #94993d,
 
-$solarized_dark_header_head_chosen    : rgba(#859900, .5);
-$solarized_dark_line_head_chosen      : rgba(#859900, .35);
-$solarized_dark_button_head_chosen    : #39800d;
+  solarized_light_header_origin_neutral : rgba(#2878C9, .37),
+  solarized_light_line_origin_neutral   : rgba(#2878C9, .15),
+  solarized_light_button_origin_neutral : #60A1BF,
 
-$solarized_dark_header_origin_neutral : rgba(#2878C9, .35);
-$solarized_dark_line_origin_neutral   : rgba(#2878C9, .15);
-$solarized_dark_button_origin_neutral : #086799;
+  solarized_light_header_origin_chosen  : rgba(#2878C9, .6),
+  solarized_light_line_origin_chosen    : rgba(#2878C9, .37),
+  solarized_light_button_origin_chosen  : #2482b2,
 
-$solarized_dark_header_origin_chosen  : rgba(#2878C9, .6);
-$solarized_dark_line_origin_chosen    : rgba(#2878C9, .35);
-$solarized_dark_button_origin_chosen  : #0082CC;
-
-$solarized_dark_header_not_chosen     : rgba(#FFF, .25);
-$solarized_dark_line_not_chosen       : rgba(#FFF, .15);
+  solarized_light_header_not_chosen     : rgba(#FFF, .37),
+  solarized_light_line_not_chosen       : rgba(#FFF, .2),
 
 
+  solarized_dark_header_head_neutral   : rgba(#859900, .35),
+  solarized_dark_line_head_neutral     : rgba(#859900, .15),
+  solarized_dark_button_head_neutral   : #376b20,
 
-$monokai_header_head_neutral   : rgba(#A6E22E, .25);
-$monokai_line_head_neutral     : rgba(#A6E22E, .1);
-$monokai_button_head_neutral   : #376b20;
+  solarized_dark_header_head_chosen    : rgba(#859900, .5),
+  solarized_dark_line_head_chosen      : rgba(#859900, .35),
+  solarized_dark_button_head_chosen    : #39800d,
 
-$monokai_header_head_chosen    : rgba(#A6E22E, .4);
-$monokai_line_head_chosen      : rgba(#A6E22E, .25);
-$monokai_button_head_chosen    : #39800d;
+  solarized_dark_header_origin_neutral : rgba(#2878C9, .35),
+  solarized_dark_line_origin_neutral   : rgba(#2878C9, .15),
+  solarized_dark_button_origin_neutral : #086799,
 
-$monokai_header_origin_neutral : rgba(#60D9F1, .35);
-$monokai_line_origin_neutral   : rgba(#60D9F1, .15);
-$monokai_button_origin_neutral : #38848C;
+  solarized_dark_header_origin_chosen  : rgba(#2878C9, .6),
+  solarized_dark_line_origin_chosen    : rgba(#2878C9, .35),
+  solarized_dark_button_origin_chosen  : #0082CC,
 
-$monokai_header_origin_chosen  : rgba(#60D9F1, .5);
-$monokai_line_origin_chosen    : rgba(#60D9F1, .35);
-$monokai_button_origin_chosen  : #3EA4B2;
+  solarized_dark_header_not_chosen     : rgba(#FFF, .25),
+  solarized_dark_line_not_chosen       : rgba(#FFF, .15)
+);
 
-$monokai_header_not_chosen     : rgba(#FFF, .24);
-$monokai_line_not_chosen       : rgba(#FFF, .1);
 
+@mixin color-scheme($color) {
+  .header.line_content, .diff-line-num {
+    &.origin {
+      background-color: map-get($colors, #{$color}_header_origin_neutral);
+      &.selected {
+        background-color: map-get($colors, #{$color}_header_origin_chosen);
+      }
+      &.unselected {
+        background-color: map-get($colors, #{$color}_header_not_chosen);
+      }
+    }
+    &.head {
+      background-color: map-get($colors, #{$color}_header_head_neutral);
+      &.selected {
+        background-color: map-get($colors, #{$color}_header_head_chosen);
+      }
+      &.unselected {
+        background-color: map-get($colors, #{$color}_header_not_chosen);
+      }
+    }
+  }
+
+  .line_content {
+    &.origin {
+      background-color: map-get($colors, #{$color}_line_origin_neutral);
+      &.selected {
+        background-color: map-get($colors, #{$color}_line_origin_chosen);
+      }
+      &.unselected {
+        background-color: map-get($colors, #{$color}_line_not_chosen);
+      }
+    }
+    &.head {
+      background-color: map-get($colors, #{$color}_line_head_neutral);
+      &.selected {
+        background-color: map-get($colors, #{$color}_line_head_chosen);
+      }
+      &.unselected {
+        background-color: map-get($colors, #{$color}_line_not_chosen);
+      }
+    }
+  }
+}
 
 
 #conflicts {
 
   .white {
-    .header.line_content, .diff-line-num {
-      &.origin {
-        background-color: $white_header_origin_neutral;
-        &.selected {
-          background-color: $white_header_origin_chosen;
-        }
-        &.unselected {
-          background-color: $white_header_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $white_header_head_neutral;
-        &.selected {
-          background-color: $white_header_head_chosen;
-        }
-        &.unselected {
-          background-color: $white_header_not_chosen;
-        }
-      }
-    }
-
-    .line_content {
-      &.origin {
-        background-color: $white_line_origin_neutral;
-        &.selected {
-          background-color: $white_line_origin_chosen;
-        }
-        &.unselected {
-          background-color: $white_line_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $white_line_head_neutral;
-        &.selected {
-          background-color: $white_line_head_chosen;
-        }
-        &.unselected {
-          background-color: $white_line_not_chosen;
-        }
-      }
-    }
+    @include color-scheme('white')
   }
 
-
   .dark {
-    .header.line_content, .diff-line-num {
-      &.origin {
-        background-color: $dark_header_origin_neutral;
-        &.selected {
-          background-color: $dark_header_origin_chosen;
-        }
-        &.unselected {
-          background-color: $dark_header_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $dark_header_head_neutral;
-        &.selected {
-          background-color: $dark_header_head_chosen;
-        }
-        &.unselected {
-          background-color: $dark_header_not_chosen;
-        }
-      }
-    }
-
-    .line_content {
-      &.origin {
-        background-color: $dark_line_origin_neutral;
-        &.selected {
-          background-color: $dark_line_origin_chosen;
-        }
-        &.unselected {
-          background-color: $dark_line_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $dark_line_head_neutral;
-        &.selected {
-          background-color: $dark_line_head_chosen;
-        }
-        &.unselected {
-          background-color: $dark_line_not_chosen;
-        }
-      }
-    }
+    @include color-scheme('dark')
   }
 
-
-  .solarized-light {
-    .header.line_content, .diff-line-num {
-      &.origin {
-        background-color: $solarized_light_header_origin_neutral;
-        &.selected {
-          background-color: $solarized_light_header_origin_chosen;
-        }
-        &.unselected {
-          background-color: $solarized_light_header_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $solarized_light_header_head_neutral;
-        &.selected {
-          background-color: $solarized_light_header_head_chosen;
-        }
-        &.unselected {
-          background-color: $solarized_light_header_not_chosen;
-        }
-      }
-    }
-
-    .line_content {
-      &.origin {
-        background-color: $solarized_light_line_origin_neutral;
-        &.selected {
-          background-color: $solarized_light_line_origin_chosen;
-        }
-        &.unselected {
-          background-color: $solarized_light_line_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $solarized_light_line_head_neutral;
-        &.selected {
-          background-color: $solarized_light_line_head_chosen;
-        }
-        &.unselected {
-          background-color: $solarized_light_line_not_chosen;
-        }
-      }
-    }
-  }
-
-
-  .solarized-dark {
-    .header.line_content, .diff-line-num {
-      &.origin {
-        background-color: $solarized_dark_header_origin_neutral;
-        &.selected {
-          background-color: $solarized_dark_header_origin_chosen;
-        }
-        &.unselected {
-          background-color: $solarized_dark_header_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $solarized_dark_header_head_neutral;
-        &.selected {
-          background-color: $solarized_dark_header_head_chosen;
-        }
-        &.unselected {
-          background-color: $solarized_dark_header_not_chosen;
-        }
-      }
-    }
-
-    .line_content {
-      &.origin {
-        background-color: $solarized_dark_line_origin_neutral;
-        &.selected {
-          background-color: $solarized_dark_line_origin_chosen;
-        }
-        &.unselected {
-          background-color: $solarized_dark_line_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $solarized_dark_line_head_neutral;
-        &.selected {
-          background-color: $solarized_dark_line_head_chosen;
-        }
-        &.unselected {
-          background-color: $solarized_dark_line_not_chosen;
-        }
-      }
-    }
-  }
-
-
   .monokai {
-    .header.line_content, .diff-line-num {
-      &.origin {
-        background-color: $monokai_header_origin_neutral;
-        &.selected {
-          background-color: $monokai_header_origin_chosen;
-        }
-        &.unselected {
-          background-color: $monokai_header_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $monokai_header_head_neutral;
-        &.selected {
-          background-color: $monokai_header_head_chosen;
-        }
-        &.unselected {
-          background-color: $monokai_header_not_chosen;
-        }
-      }
-    }
-
-    .line_content {
-      &.origin {
-        background-color: $monokai_line_origin_neutral;
-        &.selected {
-          background-color: $monokai_line_origin_chosen;
-        }
-        &.unselected {
-          background-color: $monokai_line_not_chosen;
-        }
-      }
-      &.head {
-        background-color: $monokai_line_head_neutral;
-        &.selected {
-          background-color: $monokai_line_head_chosen;
-        }
-        &.unselected {
-          background-color: $monokai_line_not_chosen;
-        }
-      }
-    }
+    @include color-scheme('monokai')
   }
 
+  .solarized-light {
+    @include color-scheme('solarized_light')
+  }
+
+  .solarized-dark {
+    @include color-scheme('solarized_dark')
+  }
 
   .diff-wrap-lines .line_content {
     white-space: normal;

From cf4cbb018e229b80e8fd0ca427e63f337ef6bdff Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:36:13 -0500
Subject: [PATCH 67/90] Rename `can_resolve_conflicts_in_ui?` to
 `conflicts_can_be_resolved_in_ui?`

---
 .../projects/merge_requests_controller.rb        |  2 +-
 app/models/merge_request.rb                      | 12 +++++++-----
 .../widget/open/_conflicts.html.haml             |  2 +-
 spec/models/merge_request_spec.rb                | 16 ++++++++--------
 4 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 2edd76de4c4..9d3a2addcde 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -135,7 +135,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
       format.html { define_discussion_vars }
 
       format.json do
-        if @merge_request.can_resolve_conflicts_in_ui?
+        if @merge_request.conflicts_can_be_resolved_in_ui?
           render json: @merge_request.conflicts
         else
           render json: {
diff --git a/app/models/merge_request.rb b/app/models/merge_request.rb
index 630d31a5d5c..b41d3b6891a 100644
--- a/app/models/merge_request.rb
+++ b/app/models/merge_request.rb
@@ -720,14 +720,16 @@ class MergeRequest < ActiveRecord::Base
     @conflicts ||= Gitlab::Conflict::FileCollection.new(self)
   end
 
-  def can_resolve_conflicts_in_ui?
-    return false unless cannot_be_merged?
-    return false unless has_complete_diff_refs?
+  def conflicts_can_be_resolved_in_ui?
+    return @conflicts_can_be_resolved_in_ui if defined?(@conflicts_can_be_resolved_in_ui)
+
+    return @conflicts_can_be_resolved_in_ui = false unless cannot_be_merged?
+    return @conflicts_can_be_resolved_in_ui = false unless has_complete_diff_refs?
 
     begin
-      conflicts.files.each(&:lines)
+      @conflicts_can_be_resolved_in_ui = conflicts.files.each(&:lines)
     rescue Gitlab::Conflict::Parser::ParserError, Gitlab::Conflict::FileCollection::ConflictSideMissing
-      false
+      @conflicts_can_be_resolved_in_ui = false
     end
   end
 end
diff --git a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
index 582a82c7a71..bedf45fb89d 100644
--- a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
@@ -4,7 +4,7 @@
 
 %p
   Please
-  - if @merge_request.can_resolve_conflicts_in_ui?
+  - if @merge_request.conflicts_can_be_resolved_in_ui?
     = link_to "resolve these conflicts", conflicts_namespace_project_merge_request_path(@project.namespace, @project, @merge_request)
     or
   - if @merge_request.can_be_merged_via_command_line_by?(current_user)
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index b4741bd3bcb..a9d8081656d 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -742,7 +742,7 @@ describe MergeRequest, models: true do
     end
   end
 
-  describe '#can_resolve_conflicts_in_ui?' do
+  describe '#conflicts_can_be_resolved_in_ui?' do
     def create_merge_request(source_branch)
       create(:merge_request, source_branch: source_branch, target_branch: 'conflict-start') do |mr|
         mr.mark_as_unmergeable
@@ -753,44 +753,44 @@ describe MergeRequest, models: true do
       merge_request = create_merge_request('master')
       merge_request.mark_as_mergeable
 
-      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+      expect(merge_request.conflicts_can_be_resolved_in_ui?).to be_falsey
     end
 
     it 'returns a falsey value when the MR does not support new diff notes' do
       merge_request = create_merge_request('conflict-resolvable')
       merge_request.merge_request_diff.update_attributes(start_commit_sha: nil)
 
-      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+      expect(merge_request.conflicts_can_be_resolved_in_ui?).to be_falsey
     end
 
     it 'returns a falsey value when the conflicts contain a large file' do
       merge_request = create_merge_request('conflict-too-large')
 
-      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+      expect(merge_request.conflicts_can_be_resolved_in_ui?).to be_falsey
     end
 
     it 'returns a falsey value when the conflicts contain a binary file' do
       merge_request = create_merge_request('conflict-binary-file')
 
-      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+      expect(merge_request.conflicts_can_be_resolved_in_ui?).to be_falsey
     end
 
     it 'returns a falsey value when the conflicts contain a file with ambiguous conflict markers' do
       merge_request = create_merge_request('conflict-contains-conflict-markers')
 
-      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+      expect(merge_request.conflicts_can_be_resolved_in_ui?).to be_falsey
     end
 
     it 'returns a falsey value when the conflicts contain a file edited in one branch and deleted in another' do
       merge_request = create_merge_request('conflict-missing-side')
 
-      expect(merge_request.can_resolve_conflicts_in_ui?).to be_falsey
+      expect(merge_request.conflicts_can_be_resolved_in_ui?).to be_falsey
     end
 
     it 'returns a truthy value when the conflicts are resolvable in the UI' do
       merge_request = create_merge_request('conflict-resolvable')
 
-      expect(merge_request.can_resolve_conflicts_in_ui?).to be_truthy
+      expect(merge_request.conflicts_can_be_resolved_in_ui?).to be_truthy
     end
   end
 end

From 9eca67c950829698dabb93102804a6ddf89d5f8d Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:36:58 -0500
Subject: [PATCH 68/90] Verify user is signed in and can actually resolve
 conflicts

---
 app/controllers/projects/merge_requests_controller.rb     | 6 ++++++
 app/models/merge_request.rb                               | 5 +++++
 .../merge_requests/widget/open/_conflicts.html.haml       | 8 +++++---
 3 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 9d3a2addcde..0daec0017da 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -28,6 +28,8 @@ class Projects::MergeRequestsController < Projects::ApplicationController
   # Allow modify merge_request
   before_action :authorize_update_merge_request!, only: [:close, :edit, :update, :remove_wip, :sort]
 
+  before_action :authorize_can_resolve_conflicts!, only: [:conflicts, :resolve_conflicts]
+
   def index
     terms = params['issue_search']
     @merge_requests = merge_requests_collection
@@ -368,6 +370,10 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     return render_404 unless can?(current_user, :admin_merge_request, @merge_request)
   end
 
+  def authorize_can_resolve_conflicts!
+    return render_404 unless @merge_request.conflicts_can_be_resolved_by?(current_user)
+  end
+
   def module_enabled
     return render_404 unless @project.merge_requests_enabled
   end
diff --git a/app/models/merge_request.rb b/app/models/merge_request.rb
index b41d3b6891a..c1e95b1bfbf 100644
--- a/app/models/merge_request.rb
+++ b/app/models/merge_request.rb
@@ -720,6 +720,11 @@ class MergeRequest < ActiveRecord::Base
     @conflicts ||= Gitlab::Conflict::FileCollection.new(self)
   end
 
+  def conflicts_can_be_resolved_by?(user)
+    access = ::Gitlab::UserAccess.new(user, project: source_project)
+    access.can_push_to_branch?(source_branch)
+  end
+
   def conflicts_can_be_resolved_in_ui?
     return @conflicts_can_be_resolved_in_ui if defined?(@conflicts_can_be_resolved_in_ui)
 
diff --git a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
index bedf45fb89d..60ea0795bfb 100644
--- a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
@@ -4,9 +4,11 @@
 
 %p
   Please
-  - if @merge_request.conflicts_can_be_resolved_in_ui?
-    = link_to "resolve these conflicts", conflicts_namespace_project_merge_request_path(@project.namespace, @project, @merge_request)
-    or
+  - if @merge_request.conflicts_can_be_resolved_by?(current_user)
+    - if @merge_request.conflicts_can_be_resolved_in_ui?
+      = link_to "resolve these conflicts", conflicts_namespace_project_merge_request_path(@project.namespace, @project, @merge_request)
+      or
+
   - if @merge_request.can_be_merged_via_command_line_by?(current_user)
     #{link_to "merge this request manually", "#modal_merge_info", class: "how_to_merge_link vlink", "data-toggle" => "modal"}.
   - else

From 5e1e08e5ceee070582138c33e38bc8743583d064 Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:38:08 -0500
Subject: [PATCH 69/90] Show appropriate message when conflicts have already
 been resolved

---
 .../projects/merge_requests_controller.rb          | 14 +++++++++++++-
 .../projects/merge_requests/conflicts.html.haml    | 12 ++++++------
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 0daec0017da..172df9e1eb1 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -139,9 +139,14 @@ class Projects::MergeRequestsController < Projects::ApplicationController
       format.json do
         if @merge_request.conflicts_can_be_resolved_in_ui?
           render json: @merge_request.conflicts
+        elsif @merge_request.can_be_merged?
+          render json: {
+            message: 'The merge conflicts for this merge request have already been resolved. Please return to the merge request.',
+            type: 'error'
+          }
         else
           render json: {
-            message: 'Unable to resolve conflicts in the web interface for this merge request.',
+            message: 'The merge conflicts for this merge request cannot be resolved through GitLab. Please try to resolve them locally.',
             type: 'error'
           }
         end
@@ -150,6 +155,13 @@ class Projects::MergeRequestsController < Projects::ApplicationController
   end
 
   def resolve_conflicts
+    return render_404 unless @merge_request.conflicts_can_be_resolved_in_ui?
+
+    if @merge_request.can_be_merged?
+      render status: :bad_request, json: { message: 'The merge conflicts for this merge request have already been resolved.' }
+      return
+    end
+
     begin
       MergeRequests::ResolveService.new(project, current_user, params).execute(@merge_request)
 
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index 6eda9bb3f65..72355323090 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -17,12 +17,12 @@
   .loading{"v-if" => "isLoading"}
     %i.fa.fa-spinner.fa-spin
 
-  .content-block.oneline-block{"v-if" => "hasError"}
-    %p {{conflictsData.errorMessage}}
+  .nothing-here-block{"v-if" => "hasError"}
+    {{conflictsData.errorMessage}}
 
-  = render partial: "projects/merge_requests/conflicts/commit_stats.html.haml"
+  = render partial: "projects/merge_requests/conflicts/commit_stats"
 
   .files-wrapper{"v-if" => "!isLoading && !hasError"}
-    = render partial: "projects/merge_requests/conflicts/parallel_view.html.haml", locals: { class_bindings: class_bindings }
-    = render partial: "projects/merge_requests/conflicts/inline_view.html.haml", locals: { class_bindings: class_bindings }
-    = render partial: "projects/merge_requests/conflicts/submit_form.html.haml"
+    = render partial: "projects/merge_requests/conflicts/parallel_view", locals: { class_bindings: class_bindings }
+    = render partial: "projects/merge_requests/conflicts/inline_view", locals: { class_bindings: class_bindings }
+    = render partial: "projects/merge_requests/conflicts/submit_form"

From add01596cf497e0138282830fb1cc43f2c0bb124 Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:38:33 -0500
Subject: [PATCH 70/90] Show tooltip when conflicts cannot be resolved through
 GitLab

---
 .../merge_requests/widget/open/_conflicts.html.haml       | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
index 60ea0795bfb..af3096f04d9 100644
--- a/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
+++ b/app/views/projects/merge_requests/widget/open/_conflicts.html.haml
@@ -7,7 +7,13 @@
   - if @merge_request.conflicts_can_be_resolved_by?(current_user)
     - if @merge_request.conflicts_can_be_resolved_in_ui?
       = link_to "resolve these conflicts", conflicts_namespace_project_merge_request_path(@project.namespace, @project, @merge_request)
-      or
+    - else
+      %span.has-tooltip{title: "These conflicts cannot be resolved through GitLab"}
+        resolve these conflicts locally
+  - else
+    resolve these conflicts
+
+  or
 
   - if @merge_request.can_be_merged_via_command_line_by?(current_user)
     #{link_to "merge this request manually", "#modal_merge_info", class: "how_to_merge_link vlink", "data-toggle" => "modal"}.

From 4d7c201414b8db1206e37a476d4f39457c2be1bf Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:40:00 -0500
Subject: [PATCH 71/90] =?UTF-8?q?Don=E2=80=99t=20hardcode=20paths?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 app/assets/javascripts/merge_conflict_resolver.js.es6         | 4 ++--
 app/views/projects/merge_requests/conflicts.html.haml         | 3 ++-
 .../projects/merge_requests/conflicts/_submit_form.html.haml  | 4 +---
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index ed12b2fea82..7453dbcd585 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -45,7 +45,7 @@ window.MergeConflictResolver = class MergeConflictResolver {
   fetchData() {
     const dp = this.dataProvider;
 
-    $.get('./conflicts.json')
+    $.get($('#conflicts').data('conflictsPath'))
       .done((data) => {
         dp.decorateData(this.vue, data);
       })
@@ -69,7 +69,7 @@ window.MergeConflictResolver = class MergeConflictResolver {
   commit() {
     this.vue.isSubmitting = true;
 
-    $.post('./resolve_conflicts', this.dataProvider.getCommitData())
+    $.post($('#conflicts').data('resolveConflictsPath'), this.dataProvider.getCommitData())
       .done((data) => {
         window.location.href = data.redirect_to;
       })
diff --git a/app/views/projects/merge_requests/conflicts.html.haml b/app/views/projects/merge_requests/conflicts.html.haml
index 72355323090..a524936f73c 100644
--- a/app/views/projects/merge_requests/conflicts.html.haml
+++ b/app/views/projects/merge_requests/conflicts.html.haml
@@ -13,7 +13,8 @@
 
 = render 'shared/issuable/sidebar', issuable: @merge_request
 
-#conflicts{"v-cloak" => "true"}
+#conflicts{"v-cloak" => "true", data: { conflicts_path: conflicts_namespace_project_merge_request_path(@merge_request.project.namespace, @merge_request.project, @merge_request, format: :json),
+    resolve_conflicts_path: resolve_conflicts_namespace_project_merge_request_path(@merge_request.project.namespace, @merge_request.project, @merge_request) } }
   .loading{"v-if" => "isLoading"}
     %i.fa.fa-spinner.fa-spin
 
diff --git a/app/views/projects/merge_requests/conflicts/_submit_form.html.haml b/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
index 5811fe739d3..c017fc5c4f8 100644
--- a/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
+++ b/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
@@ -13,6 +13,4 @@
     %span Commit conflict resolution
     %a.fa.fa-spin.fa-spinner{":class" => "{'hidden': !isSubmitting}"}
 
-  / FIXME: Hardcoded path
-  %a.btn.btn-cancel{"href" => "diffs"}
-    Cancel
+  = link_to "Cancel", namespace_project_merge_request_path(@merge_request.project.namespace, @merge_request.project, @merge_request), class: "btn btn-cancel"

From 8dba8e2d42e0e637e2267b21fc06bd9aa8d2efcd Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:40:43 -0500
Subject: [PATCH 72/90] Get conflict resolution to work for MRs from forks

---
 app/controllers/projects/merge_requests_controller.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 172df9e1eb1..076b5254b1b 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -163,7 +163,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     end
 
     begin
-      MergeRequests::ResolveService.new(project, current_user, params).execute(@merge_request)
+      MergeRequests::ResolveService.new(@merge_request.source_project, current_user, params).execute(@merge_request)
 
       flash[:conflicts_message] = 'Merge conflicts resolved.'
       flash.keep

From 1711a384e4ff304e7206c513cf25d91206648970 Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:41:48 -0500
Subject: [PATCH 73/90] =?UTF-8?q?Prevent=20=E2=80=9CThis=20merge=20request?=
 =?UTF-8?q?=20contains=20merge=20conflicts=E2=80=9D=20from=20being=20shown?=
 =?UTF-8?q?=20after=20resolution=20because=20of=20slow=20background=20work?=
 =?UTF-8?q?ers?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 app/assets/javascripts/merge_request_widget.js             | 2 +-
 app/controllers/projects/merge_requests_controller.rb      | 2 +-
 app/views/projects/merge_requests/widget/_merged.html.haml | 2 +-
 app/views/projects/merge_requests/widget/_open.html.haml   | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/app/assets/javascripts/merge_request_widget.js b/app/assets/javascripts/merge_request_widget.js
index 362aaa906d0..77b12a17f0c 100644
--- a/app/assets/javascripts/merge_request_widget.js
+++ b/app/assets/javascripts/merge_request_widget.js
@@ -53,7 +53,7 @@
           return function(data) {
             var callback, urlSuffix;
             if (data.state === "merged") {
-              urlSuffix = deleteSourceBranch ? '?delete_source=true' : '';
+              urlSuffix = deleteSourceBranch ? '?deleted_source_branch=true' : '';
               return window.location.href = window.location.pathname + urlSuffix;
             } else if (data.merge_error) {
               return $('.mr-widget-body').html("<h4>" + data.merge_error + "</h4>");
diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 076b5254b1b..3163a3d6698 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -168,7 +168,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
       flash[:conflicts_message] = 'Merge conflicts resolved.'
       flash.keep
 
-      render json: { redirect_to: namespace_project_merge_request_url(@project.namespace, @project, @merge_request) }
+      render json: { redirect_to: namespace_project_merge_request_url(@project.namespace, @project, @merge_request, resolved_conflicts: true) }
     rescue Gitlab::Conflict::File::MissingResolution => e
       render status: :bad_request, json: { message: e.message }
     end
diff --git a/app/views/projects/merge_requests/widget/_merged.html.haml b/app/views/projects/merge_requests/widget/_merged.html.haml
index 19b5d0ff066..7794d6d7df2 100644
--- a/app/views/projects/merge_requests/widget/_merged.html.haml
+++ b/app/views/projects/merge_requests/widget/_merged.html.haml
@@ -6,7 +6,7 @@
       - if @merge_request.merge_event
         by #{link_to_member(@project, @merge_request.merge_event.author, avatar: true)}
         #{time_ago_with_tooltip(@merge_request.merge_event.created_at)}
-    - if !@merge_request.source_branch_exists? || (params[:delete_source] == 'true')
+    - if !@merge_request.source_branch_exists? || params[:deleted_source_branch]
       %p
         The changes were merged into
         #{link_to @merge_request.target_branch, namespace_project_commits_path(@project.namespace, @project, @merge_request.target_branch), class: "label-branch"}.
diff --git a/app/views/projects/merge_requests/widget/_open.html.haml b/app/views/projects/merge_requests/widget/_open.html.haml
index dc18f715f25..f83490654ae 100644
--- a/app/views/projects/merge_requests/widget/_open.html.haml
+++ b/app/views/projects/merge_requests/widget/_open.html.haml
@@ -9,7 +9,7 @@
       = render 'projects/merge_requests/widget/open/missing_branch'
     - elsif @merge_request.unchecked?
       = render 'projects/merge_requests/widget/open/check'
-    - elsif @merge_request.cannot_be_merged?
+    - elsif @merge_request.cannot_be_merged? && !params[:resolved_conflicts]
       = render 'projects/merge_requests/widget/open/conflicts'
     - elsif @merge_request.work_in_progress?
       = render 'projects/merge_requests/widget/open/wip'

From 83925ef45896e61ffbe92bbde34209a82d55427b Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:42:10 -0500
Subject: [PATCH 74/90] Use a regular flash message after resolution is
 complete

---
 app/controllers/projects/merge_requests_controller.rb       | 3 +--
 app/views/projects/merge_requests/widget/_heading.html.haml | 6 ------
 2 files changed, 1 insertion(+), 8 deletions(-)

diff --git a/app/controllers/projects/merge_requests_controller.rb b/app/controllers/projects/merge_requests_controller.rb
index 3163a3d6698..bf67fdb3979 100644
--- a/app/controllers/projects/merge_requests_controller.rb
+++ b/app/controllers/projects/merge_requests_controller.rb
@@ -165,8 +165,7 @@ class Projects::MergeRequestsController < Projects::ApplicationController
     begin
       MergeRequests::ResolveService.new(@merge_request.source_project, current_user, params).execute(@merge_request)
 
-      flash[:conflicts_message] = 'Merge conflicts resolved.'
-      flash.keep
+      flash[:notice] = 'All merge conflicts were resolved. The merge request can now be merged.'
 
       render json: { redirect_to: namespace_project_merge_request_url(@project.namespace, @project, @merge_request, resolved_conflicts: true) }
     rescue Gitlab::Conflict::File::MissingResolution => e
diff --git a/app/views/projects/merge_requests/widget/_heading.html.haml b/app/views/projects/merge_requests/widget/_heading.html.haml
index 4e96ab0595a..6ef640bb654 100644
--- a/app/views/projects/merge_requests/widget/_heading.html.haml
+++ b/app/views/projects/merge_requests/widget/_heading.html.haml
@@ -42,9 +42,3 @@
     .ci_widget.ci-error{style: "display:none"}
       = icon("times-circle")
       Could not connect to the CI server. Please check your settings and try again.
-
-- if flash[:conflicts_message]
-  .mr-widget-heading
-    .ci_widget
-      = ci_icon_for_status('success')
-      = flash[:conflicts_message]

From 254dbad8f7c2213f87087858ff31a62f0d41a189 Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:42:35 -0500
Subject: [PATCH 75/90] Fix bug where conflict view would have one too many
 context sections

---
 lib/gitlab/conflict/file.rb | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/gitlab/conflict/file.rb b/lib/gitlab/conflict/file.rb
index 926b65d46fc..0a1fd27ced5 100644
--- a/lib/gitlab/conflict/file.rb
+++ b/lib/gitlab/conflict/file.rb
@@ -72,9 +72,11 @@ module Gitlab
       def sections
         return @sections if @sections
 
-        chunked_lines = lines.chunk { |line| line.type.nil? }
+        chunked_lines = lines.chunk { |line| line.type.nil? }.to_a
         match_line = nil
 
+        sections_count = chunked_lines.size
+
         @sections = chunked_lines.flat_map.with_index do |(no_conflict, lines), i|
           section = nil
 
@@ -82,7 +84,7 @@ module Gitlab
           # always shown in full.
           if no_conflict
             conflict_before = i > 0
-            conflict_after = chunked_lines.peek
+            conflict_after = (sections_count - i) > 1
 
             if conflict_before && conflict_after
               # Create a gap in a long context section.

From c19ad19efd08e18a4d4b2a8b389d4409f3ca6615 Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:43:17 -0500
Subject: [PATCH 76/90] =?UTF-8?q?=E2=80=9CShowing=20N=20conflicts=20for=20?=
 =?UTF-8?q?A=20into=20B=E2=80=9D=20->=20=E2=80=9CShowing=20N=20conflicts?=
 =?UTF-8?q?=20between=20A=20and=20B=E2=80=9D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../projects/merge_requests/conflicts/_commit_stats.html.haml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml b/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml
index 8c7f67370e4..16dc160be4a 100644
--- a/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml
+++ b/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml
@@ -14,7 +14,7 @@
     .commit-stat-summary
       Showing
       %strong.cred {{conflictsCount}} conflicts
-      for
+      between
       %strong {{conflictsData.source_branch}}
-      into
+      and
       %strong {{conflictsData.target_branch}}

From c15146249584b164d15420a1ed1e9f69e7fb3ae1 Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Wed, 10 Aug 2016 22:43:29 -0500
Subject: [PATCH 77/90] Minor code style tweaks in views

---
 .../merge_requests/conflicts/_inline_view.html.haml | 13 ++++++-------
 .../conflicts/_parallel_view.html.haml              | 11 ++++++-----
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/app/views/projects/merge_requests/conflicts/_inline_view.html.haml b/app/views/projects/merge_requests/conflicts/_inline_view.html.haml
index 46141281ed6..19c7da4b5e3 100644
--- a/app/views/projects/merge_requests/conflicts/_inline_view.html.haml
+++ b/app/views/projects/merge_requests/conflicts/_inline_view.html.haml
@@ -11,19 +11,18 @@
       .diff-wrap-lines.code.file-content.js-syntax-highlight
         %table
           %tr.line_holder.diff-inline{"v-for" => "line in file.inlineLines"}
-
             %template{"v-if" => "!line.isHeader"}
-              %td.diff-line-num.new_line{":class" => "#{class_bindings}"}
+              %td.diff-line-num.new_line{":class" => class_bindings}
                 %a {{line.new_line}}
-              %td.diff-line-num.old_line{":class" => "#{class_bindings}"}
+              %td.diff-line-num.old_line{":class" => class_bindings}
                 %a {{line.old_line}}
-              %td.line_content{":class" => "#{class_bindings}"}
+              %td.line_content{":class" => class_bindings}
                 {{{line.richText}}}
 
             %template{"v-if" => "line.isHeader"}
-              %td.diff-line-num.header{":class" => "#{class_bindings}"}
-              %td.diff-line-num.header{":class" => "#{class_bindings}"}
-              %td.line_content.header{":class" => "#{class_bindings}"}
+              %td.diff-line-num.header{":class" => class_bindings}
+              %td.diff-line-num.header{":class" => class_bindings}
+              %td.line_content.header{":class" => class_bindings}
                 %strong {{{line.richText}}}
                 %button.btn{"@click" => "handleSelected(line.id, line.section)"}
                   {{line.buttonTitle}}
diff --git a/app/views/projects/merge_requests/conflicts/_parallel_view.html.haml b/app/views/projects/merge_requests/conflicts/_parallel_view.html.haml
index cabe4751690..2e6f67c2eaf 100644
--- a/app/views/projects/merge_requests/conflicts/_parallel_view.html.haml
+++ b/app/views/projects/merge_requests/conflicts/_parallel_view.html.haml
@@ -1,11 +1,12 @@
 .files{"v-show" => "isParallel"}
   .diff-file.file-holder.conflict.parallel-view{"v-for" => "file in conflictsData.files"}
     .file-title
-      %i.fa.fa-fw.fa{":class" => "file.iconClass"}
+      %i.fa.fa-fw{":class" => "file.iconClass"}
       %strong {{file.filePath}}
       .file-actions
         %a.btn.view-file.btn-file-option{":href" => "file.blobPath"}
           View file @{{conflictsData.shortCommitSha}}
+
     .diff-content.diff-wrap-lines
       .diff-wrap-lines.code.file-content.js-syntax-highlight
         %table
@@ -13,14 +14,14 @@
             %template{"v-for" => "line in section"}
 
               %template{"v-if" => "line.isHeader"}
-                %td.diff-line-num.header{":class" => "#{class_bindings}"}
-                %td.line_content.header{":class" => "#{class_bindings}"}
+                %td.diff-line-num.header{":class" => class_bindings}
+                %td.line_content.header{":class" => class_bindings}
                   %strong {{line.richText}}
                   %button.btn{"@click" => "handleSelected(line.id, line.section)"}
                     {{line.buttonTitle}}
 
               %template{"v-if" => "!line.isHeader"}
-                %td.diff-line-num.old_line{":class" => "#{class_bindings}"}
+                %td.diff-line-num.old_line{":class" => class_bindings}
                   {{line.lineNumber}}
-                %td.line_content.parallel{":class" => "#{class_bindings}"}
+                %td.line_content.parallel{":class" => class_bindings}
                   {{{line.richText}}}

From 65747107099d7ac70879cb576042fceef1c1c746 Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@selenight.nl>
Date: Thu, 11 Aug 2016 19:22:42 -0500
Subject: [PATCH 78/90] Fix bug where merge widget wouldn't show up after
 resolving conflicts

---
 .../projects/merge_requests/widget/_open.html.haml     | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/app/views/projects/merge_requests/widget/_open.html.haml b/app/views/projects/merge_requests/widget/_open.html.haml
index f83490654ae..6f5ee5f16c5 100644
--- a/app/views/projects/merge_requests/widget/_open.html.haml
+++ b/app/views/projects/merge_requests/widget/_open.html.haml
@@ -1,6 +1,12 @@
 .mr-state-widget
   = render 'projects/merge_requests/widget/heading'
   .mr-widget-body
+    -# After conflicts are resolved, the user is redirected back to the MR page.
+    -# There is a short window before background workers run and GitLab processes
+    -# the new push and commits, during which it will think the conflicts still exist.
+    -# We send this param to get the widget to treat the MR as having no more conflicts.
+    - resolved_conflicts = params[:resolved_conflicts]
+
     - if @project.archived?
       = render 'projects/merge_requests/widget/open/archived'
     - elsif @merge_request.commits.blank?
@@ -9,7 +15,7 @@
       = render 'projects/merge_requests/widget/open/missing_branch'
     - elsif @merge_request.unchecked?
       = render 'projects/merge_requests/widget/open/check'
-    - elsif @merge_request.cannot_be_merged? && !params[:resolved_conflicts]
+    - elsif @merge_request.cannot_be_merged? && !resolved_conflicts
       = render 'projects/merge_requests/widget/open/conflicts'
     - elsif @merge_request.work_in_progress?
       = render 'projects/merge_requests/widget/open/wip'
@@ -19,7 +25,7 @@
       = render 'projects/merge_requests/widget/open/not_allowed'
     - elsif !@merge_request.mergeable_ci_state? && @pipeline && @pipeline.failed?
       = render 'projects/merge_requests/widget/open/build_failed'
-    - elsif @merge_request.can_be_merged?
+    - elsif @merge_request.can_be_merged? || resolved_conflicts
       = render 'projects/merge_requests/widget/open/accept'
 
   - if mr_closes_issues.present?

From 66241c1b08eeb9bf538c1feebd046ec18ea07c87 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Thu, 11 Aug 2016 20:51:07 +0300
Subject: [PATCH 79/90] Prefer lowercase hex values as declared in styling
 guideline.

---
 .../stylesheets/pages/merge_conflicts.scss    | 78 +++++++++----------
 1 file changed, 39 insertions(+), 39 deletions(-)

diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index af5f778cb7e..0c59a73a718 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -1,30 +1,30 @@
 $colors: (
   white_header_head_neutral   : #e1fad7,
   white_line_head_neutral     : #effdec,
-  white_button_head_neutral   : #9ADB84,
+  white_button_head_neutral   : #9adb84,
 
   white_header_head_chosen    : #baf0a8,
   white_line_head_chosen      : #e1fad7,
-  white_button_head_chosen    : #52C22D,
+  white_button_head_chosen    : #52c22d,
 
   white_header_origin_neutral : #e0f0ff,
   white_line_origin_neutral   : #f2f9ff,
-  white_button_origin_neutral : #87C2FA,
+  white_button_origin_neutral : #87c2fa,
 
   white_header_origin_chosen  : #add8ff,
   white_line_origin_chosen    : #e0f0ff,
-  white_button_origin_chosen  : #268CED,
+  white_button_origin_chosen  : #268ced,
 
-  white_header_not_chosen     : #F0F0F0,
+  white_header_not_chosen     : #f0f0f0,
   white_line_not_chosen       : #f9f9f9,
 
 
-  dark_header_head_neutral   : rgba(#33FF33, .2),
-  dark_line_head_neutral     : rgba(#33FF33, .1),
-  dark_button_head_neutral   : #40874F,
+  dark_header_head_neutral   : rgba(#33ff33, .2),
+  dark_line_head_neutral     : rgba(#33ff33, .1),
+  dark_button_head_neutral   : #40874f,
 
-  dark_header_head_chosen    : rgba(#33FF33, .33),
-  dark_line_head_chosen      : rgba(#33FF33, .2),
+  dark_header_head_chosen    : rgba(#33ff33, .33),
+  dark_line_head_chosen      : rgba(#33ff33, .2),
   dark_button_head_chosen    : #258537,
 
   dark_header_origin_neutral : rgba(#2878c9, .4),
@@ -35,28 +35,28 @@ $colors: (
   dark_line_origin_chosen    : rgba(#2878c9, .4),
   dark_button_origin_chosen  : #1d6cbf,
 
-  dark_header_not_chosen     : rgba(#FFF, .25),
-  dark_line_not_chosen       : rgba(#FFF, .1),
+  dark_header_not_chosen     : rgba(#fff, .25),
+  dark_line_not_chosen       : rgba(#fff, .1),
 
 
-  monokai_header_head_neutral   : rgba(#A6E22E, .25),
-  monokai_line_head_neutral     : rgba(#A6E22E, .1),
+  monokai_header_head_neutral   : rgba(#a6e22e, .25),
+  monokai_line_head_neutral     : rgba(#a6e22e, .1),
   monokai_button_head_neutral   : #376b20,
 
-  monokai_header_head_chosen    : rgba(#A6E22E, .4),
-  monokai_line_head_chosen      : rgba(#A6E22E, .25),
+  monokai_header_head_chosen    : rgba(#a6e22e, .4),
+  monokai_line_head_chosen      : rgba(#a6e22e, .25),
   monokai_button_head_chosen    : #39800d,
 
-  monokai_header_origin_neutral : rgba(#60D9F1, .35),
-  monokai_line_origin_neutral   : rgba(#60D9F1, .15),
-  monokai_button_origin_neutral : #38848C,
+  monokai_header_origin_neutral : rgba(#60d9f1, .35),
+  monokai_line_origin_neutral   : rgba(#60d9f1, .15),
+  monokai_button_origin_neutral : #38848c,
 
-  monokai_header_origin_chosen  : rgba(#60D9F1, .5),
-  monokai_line_origin_chosen    : rgba(#60D9F1, .35),
-  monokai_button_origin_chosen  : #3EA4B2,
+  monokai_header_origin_chosen  : rgba(#60d9f1, .5),
+  monokai_line_origin_chosen    : rgba(#60d9f1, .35),
+  monokai_button_origin_chosen  : #3ea4b2,
 
-  monokai_header_not_chosen     : rgba(#FFF, .24),
-  monokai_line_not_chosen       : rgba(#FFF, .1),
+  monokai_header_not_chosen     : rgba(#fff, .24),
+  monokai_line_not_chosen       : rgba(#fff, .1),
 
 
   solarized_light_header_head_neutral   : rgba(#859900, .37),
@@ -67,16 +67,16 @@ $colors: (
   solarized_light_line_head_chosen      : rgba(#859900, .37),
   solarized_light_button_head_chosen    : #94993d,
 
-  solarized_light_header_origin_neutral : rgba(#2878C9, .37),
-  solarized_light_line_origin_neutral   : rgba(#2878C9, .15),
-  solarized_light_button_origin_neutral : #60A1BF,
+  solarized_light_header_origin_neutral : rgba(#2878c9, .37),
+  solarized_light_line_origin_neutral   : rgba(#2878c9, .15),
+  solarized_light_button_origin_neutral : #60a1bf,
 
-  solarized_light_header_origin_chosen  : rgba(#2878C9, .6),
-  solarized_light_line_origin_chosen    : rgba(#2878C9, .37),
+  solarized_light_header_origin_chosen  : rgba(#2878c9, .6),
+  solarized_light_line_origin_chosen    : rgba(#2878c9, .37),
   solarized_light_button_origin_chosen  : #2482b2,
 
-  solarized_light_header_not_chosen     : rgba(#FFF, .37),
-  solarized_light_line_not_chosen       : rgba(#FFF, .2),
+  solarized_light_header_not_chosen     : rgba(#fff, .37),
+  solarized_light_line_not_chosen       : rgba(#fff, .2),
 
 
   solarized_dark_header_head_neutral   : rgba(#859900, .35),
@@ -87,16 +87,16 @@ $colors: (
   solarized_dark_line_head_chosen      : rgba(#859900, .35),
   solarized_dark_button_head_chosen    : #39800d,
 
-  solarized_dark_header_origin_neutral : rgba(#2878C9, .35),
-  solarized_dark_line_origin_neutral   : rgba(#2878C9, .15),
+  solarized_dark_header_origin_neutral : rgba(#2878c9, .35),
+  solarized_dark_line_origin_neutral   : rgba(#2878c9, .15),
   solarized_dark_button_origin_neutral : #086799,
 
-  solarized_dark_header_origin_chosen  : rgba(#2878C9, .6),
-  solarized_dark_line_origin_chosen    : rgba(#2878C9, .35),
-  solarized_dark_button_origin_chosen  : #0082CC,
+  solarized_dark_header_origin_chosen  : rgba(#2878c9, .6),
+  solarized_dark_line_origin_chosen    : rgba(#2878c9, .35),
+  solarized_dark_button_origin_chosen  : #0082cc,
 
-  solarized_dark_header_not_chosen     : rgba(#FFF, .25),
-  solarized_dark_line_not_chosen       : rgba(#FFF, .15)
+  solarized_dark_header_not_chosen     : rgba(#fff, .25),
+  solarized_dark_line_not_chosen       : rgba(#fff, .15)
 );
 
 
@@ -190,6 +190,6 @@ $colors: (
   }
 
   .btn-success .fa-spinner {
-    color: #FFF;
+    color: #fff;
   }
 }

From f6aa91700ab3e572531762270d59070e6abfc80b Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Thu, 11 Aug 2016 20:54:55 +0300
Subject: [PATCH 80/90] Fix failed test because of a copy change.

---
 spec/features/merge_requests/conflicts_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spec/features/merge_requests/conflicts_spec.rb b/spec/features/merge_requests/conflicts_spec.rb
index 0b39b4dbebb..be27a6ff3fc 100644
--- a/spec/features/merge_requests/conflicts_spec.rb
+++ b/spec/features/merge_requests/conflicts_spec.rb
@@ -61,7 +61,7 @@ feature 'Merge request conflict resolution', js: true, feature: true do
         visit current_url + '/conflicts'
         wait_for_ajax
 
-        expect(find('#conflicts')).to have_content('Unable to resolve conflicts')
+        expect(find('#conflicts')).to have_content('Please try to resolve them locally.')
       end
     end
   end

From c9f94fec4d5d53dff6ef20d8b94691e30c758f8a Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Thu, 11 Aug 2016 21:30:34 +0300
Subject: [PATCH 81/90] Change left and right position for parallel lines.

---
 app/assets/javascripts/merge_conflict_data_provider.js.es6 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 5b46dabe431..0abee3a000f 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -95,8 +95,8 @@ window.MergeConflictDataProvider = class MergeConflictDataProvider {
 
       for (let i = 0, len = linesObj.left.length; i < len; i++) {
         file.parallelLines.push([
-          linesObj.left[i],
-          linesObj.right[i]
+          linesObj.right[i],
+          linesObj.left[i]
         ]);
       }
 

From 1eaad45e71fd706a69c06b59fba0d82628c53232 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Fri, 12 Aug 2016 21:36:55 +0300
Subject: [PATCH 82/90] Remove unnecessary window exports.

---
 app/assets/javascripts/merge_conflict_data_provider.js.es6 | 4 ++--
 app/assets/javascripts/merge_conflict_resolver.js.es6      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 0abee3a000f..a96c57d1be0 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -1,10 +1,10 @@
 const HEAD_HEADER_TEXT    = 'HEAD//our changes';
 const ORIGIN_HEADER_TEXT  = 'origin//their changes';
-
 const HEAD_BUTTON_TITLE   = 'Use ours';
 const ORIGIN_BUTTON_TITLE = 'Use theirs';
 
-window.MergeConflictDataProvider = class MergeConflictDataProvider {
+
+class MergeConflictDataProvider {
 
   getInitialData() {
     const diffViewType = $.cookie('diff_view');
diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index 7453dbcd585..0b1b30b2c90 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -1,6 +1,6 @@
 //= require lib/vue
 
-window.MergeConflictResolver = class MergeConflictResolver {
+class MergeConflictResolver {
 
   constructor() {
     this.dataProvider = new MergeConflictDataProvider()

From a1d0b0398b84f872bdaee6220b76ca0de6e90f66 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Fri, 12 Aug 2016 21:48:02 +0300
Subject: [PATCH 83/90] Remove commit button loader and update title while
 committing.

---
 app/assets/javascripts/merge_conflict_data_provider.js.es6 | 7 +++++++
 app/assets/javascripts/merge_conflict_resolver.js.es6      | 5 +++--
 .../merge_requests/conflicts/_submit_form.html.haml        | 2 +-
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index a96c57d1be0..76088503323 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -239,6 +239,13 @@ class MergeConflictDataProvider {
 
   isAllResolved() {
     return !this.vueInstance.isSubmitting && this.getConflictsCount() === this.getResolvedCount();
+
+  getCommitButtonText() {
+    const initial = 'Commit conflict resolution';
+    const inProgress = 'Committing...';
+    const vue = this.vueInstance;
+
+    return vue ? vue.isSubmitting ? inProgress : initial : initial;
   }
 
 
diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index 0b1b30b2c90..6329bf8232e 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -36,8 +36,9 @@ class MergeConflictResolver {
 
     return {
       conflictsCount() { return dp.getConflictsCount() },
-      resolvedCount()  { return dp.getResolvedCount() },
-      allResolved()    { return dp.isAllResolved() }
+      resolvedCount() { return dp.getResolvedCount() },
+      readyToCommit() { return dp.isReadyToCommit() },
+      commitButtonText() { return dp.getCommitButtonText() }
     }
   }
 
diff --git a/app/views/projects/merge_requests/conflicts/_submit_form.html.haml b/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
index c017fc5c4f8..6a2b80069e8 100644
--- a/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
+++ b/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
@@ -10,7 +10,7 @@
       {{{conflictsData.commitMessage}}}
 
   %button{type: "button", class: "btn btn-success js-submit-button", ":disabled" => "!allResolved", "@click" => "commit()"}
-    %span Commit conflict resolution
     %a.fa.fa-spin.fa-spinner{":class" => "{'hidden': !isSubmitting}"}
+    %span {{commitButtonText}}
 
   = link_to "Cancel", namespace_project_merge_request_path(@merge_request.project.namespace, @merge_request.project, @merge_request), class: "btn btn-cancel"

From 14888a398c71565bf8c595ed125e52ca8fb0c5f9 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Fri, 12 Aug 2016 21:48:34 +0300
Subject: [PATCH 84/90] Disable commit button if commit message textarea empty.

---
 .../javascripts/merge_conflict_data_provider.js.es6    | 10 ++++++++--
 .../merge_requests/conflicts/_submit_form.html.haml    |  5 ++---
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 76088503323..10d8a8a8ea7 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -237,8 +237,14 @@ class MergeConflictDataProvider {
   }
 
 
-  isAllResolved() {
-    return !this.vueInstance.isSubmitting && this.getConflictsCount() === this.getResolvedCount();
+  isReadyToCommit() {
+    const { conflictsData, isSubmitting } = this.vueInstance
+    const allResolved = this.getConflictsCount() === this.getResolvedCount();
+    const hasCommitMessage = $.trim(conflictsData.commitMessage).length;
+
+    return !isSubmitting && hasCommitMessage && allResolved;
+  }
+
 
   getCommitButtonText() {
     const initial = 'Commit conflict resolution';
diff --git a/app/views/projects/merge_requests/conflicts/_submit_form.html.haml b/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
index 6a2b80069e8..78bd4133ea2 100644
--- a/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
+++ b/app/views/projects/merge_requests/conflicts/_submit_form.html.haml
@@ -6,11 +6,10 @@
 
   .commit-message-container.form-group
     .max-width-marker
-    %textarea.form-control.js-commit-message{":disabled" => "!allResolved", "v-model" => "conflictsData.commitMessage"}
+    %textarea.form-control.js-commit-message{"v-model" => "conflictsData.commitMessage"}
       {{{conflictsData.commitMessage}}}
 
-  %button{type: "button", class: "btn btn-success js-submit-button", ":disabled" => "!allResolved", "@click" => "commit()"}
-    %a.fa.fa-spin.fa-spinner{":class" => "{'hidden': !isSubmitting}"}
+  %button{type: "button", class: "btn btn-success js-submit-button", ":disabled" => "!readyToCommit", "@click" => "commit()"}
     %span {{commitButtonText}}
 
   = link_to "Cancel", namespace_project_merge_request_path(@merge_request.project.namespace, @merge_request.project, @merge_request), class: "btn btn-cancel"

From f498347d9bce861b55fcb98721e8a21db2308721 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Fri, 12 Aug 2016 23:23:47 +0300
Subject: [PATCH 85/90] CSS theme improvements for MC UI.

---
 .../stylesheets/pages/merge_conflicts.scss    | 67 +++++++++++++++----
 1 file changed, 55 insertions(+), 12 deletions(-)

diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index 0c59a73a718..a77733873eb 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -55,8 +55,8 @@ $colors: (
   monokai_line_origin_chosen    : rgba(#60d9f1, .35),
   monokai_button_origin_chosen  : #3ea4b2,
 
-  monokai_header_not_chosen     : rgba(#fff, .24),
-  monokai_line_not_chosen       : rgba(#fff, .1),
+  monokai_header_not_chosen     : rgba(#76715d, .24),
+  monokai_line_not_chosen       : rgba(#76715d, .1),
 
 
   solarized_light_header_head_neutral   : rgba(#859900, .37),
@@ -75,8 +75,8 @@ $colors: (
   solarized_light_line_origin_chosen    : rgba(#2878c9, .37),
   solarized_light_button_origin_chosen  : #2482b2,
 
-  solarized_light_header_not_chosen     : rgba(#fff, .37),
-  solarized_light_line_not_chosen       : rgba(#fff, .2),
+  solarized_light_header_not_chosen     : rgba(#839496, .37),
+  solarized_light_line_not_chosen       : rgba(#839496, .2),
 
 
   solarized_dark_header_head_neutral   : rgba(#859900, .35),
@@ -95,8 +95,8 @@ $colors: (
   solarized_dark_line_origin_chosen    : rgba(#2878c9, .35),
   solarized_dark_button_origin_chosen  : #0082cc,
 
-  solarized_dark_header_not_chosen     : rgba(#fff, .25),
-  solarized_dark_line_not_chosen       : rgba(#fff, .15)
+  solarized_dark_header_not_chosen     : rgba(#839496, .25),
+  solarized_dark_line_not_chosen       : rgba(#839496, .15)
 );
 
 
@@ -104,20 +104,60 @@ $colors: (
   .header.line_content, .diff-line-num {
     &.origin {
       background-color: map-get($colors, #{$color}_header_origin_neutral);
+      border-color: map-get($colors, #{$color}_header_origin_neutral);
+
+      button {
+        background-color: map-get($colors, #{$color}_button_origin_neutral);
+        border-color: darken(map-get($colors, #{$color}_button_origin_neutral), 15);
+      }
+
       &.selected {
         background-color: map-get($colors, #{$color}_header_origin_chosen);
+        border-color: map-get($colors, #{$color}_header_origin_chosen);
+
+        button {
+          background-color: map-get($colors, #{$color}_button_origin_chosen);
+          border-color: darken(map-get($colors, #{$color}_button_origin_chosen), 15);
+        }
       }
+
       &.unselected {
         background-color: map-get($colors, #{$color}_header_not_chosen);
+        border-color: map-get($colors, #{$color}_header_not_chosen);
+
+        button {
+          background-color: lighten(map-get($colors, #{$color}_button_origin_neutral), 15);
+          border-color: map-get($colors, #{$color}_button_origin_neutral);
+        }
       }
     }
     &.head {
       background-color: map-get($colors, #{$color}_header_head_neutral);
+      border-color: map-get($colors, #{$color}_header_head_neutral);
+
+      button {
+        background-color: map-get($colors, #{$color}_button_head_neutral);
+        border-color: darken(map-get($colors, #{$color}_button_head_neutral), 15);
+      }
+
       &.selected {
         background-color: map-get($colors, #{$color}_header_head_chosen);
+        border-color: map-get($colors, #{$color}_header_head_chosen);
+
+        button {
+          background-color: map-get($colors, #{$color}_button_head_chosen);
+          border-color: darken(map-get($colors, #{$color}_button_head_chosen), 15);
+        }
       }
+
       &.unselected {
         background-color: map-get($colors, #{$color}_header_not_chosen);
+        border-color: map-get($colors, #{$color}_header_not_chosen);
+
+        button {
+          background-color: lighten(map-get($colors, #{$color}_button_head_neutral), 15);
+          border-color: map-get($colors, #{$color}_button_head_neutral);
+        }
       }
     }
   }
@@ -125,18 +165,22 @@ $colors: (
   .line_content {
     &.origin {
       background-color: map-get($colors, #{$color}_line_origin_neutral);
+
       &.selected {
         background-color: map-get($colors, #{$color}_line_origin_chosen);
       }
+
       &.unselected {
         background-color: map-get($colors, #{$color}_line_not_chosen);
       }
     }
     &.head {
       background-color: map-get($colors, #{$color}_line_head_neutral);
+
       &.selected {
         background-color: map-get($colors, #{$color}_line_head_chosen);
       }
+
       &.unselected {
         background-color: map-get($colors, #{$color}_line_not_chosen);
       }
@@ -176,16 +220,15 @@ $colors: (
     position: relative;
 
     button {
-      border-radius: 4px;
-      border: 1px solid #e1e1e1;
-      background: #fff;
+      border-radius: 2px;
       font-size: 10px;
       position: absolute;
       right: 10px;
-      height: 17px;
-      line-height: 4px; // FIXME: 4px?
-      top: 1px;
+      padding: 0;
       outline: none;
+      color: #fff;
+      width: 75px; // static width to make 2 buttons have same width
+      height: 19px;
     }
   }
 

From 8429a57874e184d3b2d7b43d4701aafd2e92bdf6 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Sat, 13 Aug 2016 00:30:44 +0300
Subject: [PATCH 86/90] Fix hard coded plural text.

---
 app/assets/javascripts/merge_conflict_data_provider.js.es6    | 4 +++-
 .../projects/merge_requests/conflicts/_commit_stats.html.haml | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/app/assets/javascripts/merge_conflict_data_provider.js.es6 b/app/assets/javascripts/merge_conflict_data_provider.js.es6
index 10d8a8a8ea7..cd92df8ddc5 100644
--- a/app/assets/javascripts/merge_conflict_data_provider.js.es6
+++ b/app/assets/javascripts/merge_conflict_data_provider.js.es6
@@ -39,6 +39,9 @@ class MergeConflictDataProvider {
 
     vueInstance.conflictsData = data;
     vueInstance.isSubmitting = false;
+
+    const conflictsText = this.getConflictsCount() > 1 ? 'conflicts' : 'conflict';
+    vueInstance.conflictsData.conflictsText = conflictsText;
   }
 
 
@@ -101,7 +104,6 @@ class MergeConflictDataProvider {
       }
 
     });
-
   }
 
 
diff --git a/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml b/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml
index 16dc160be4a..457c467fba9 100644
--- a/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml
+++ b/app/views/projects/merge_requests/conflicts/_commit_stats.html.haml
@@ -13,7 +13,7 @@
   .js-toggle-container
     .commit-stat-summary
       Showing
-      %strong.cred {{conflictsCount}} conflicts
+      %strong.cred {{conflictsCount}} {{conflictsData.conflictsText}}
       between
       %strong {{conflictsData.source_branch}}
       and

From 882f97e4e3f23fc28752da3644a62575d2cb84e1 Mon Sep 17 00:00:00 2001
From: Douwe Maan <douwe@gitlab.com>
Date: Mon, 15 Aug 2016 20:14:36 +0000
Subject: [PATCH 87/90] Satisfy scss-lint

---
 app/assets/stylesheets/pages/merge_conflicts.scss | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/app/assets/stylesheets/pages/merge_conflicts.scss b/app/assets/stylesheets/pages/merge_conflicts.scss
index a77733873eb..1f499897c16 100644
--- a/app/assets/stylesheets/pages/merge_conflicts.scss
+++ b/app/assets/stylesheets/pages/merge_conflicts.scss
@@ -19,12 +19,12 @@ $colors: (
   white_line_not_chosen       : #f9f9f9,
 
 
-  dark_header_head_neutral   : rgba(#33ff33, .2),
-  dark_line_head_neutral     : rgba(#33ff33, .1),
+  dark_header_head_neutral   : rgba(#3f3, .2),
+  dark_line_head_neutral     : rgba(#3f3, .1),
   dark_button_head_neutral   : #40874f,
 
-  dark_header_head_chosen    : rgba(#33ff33, .33),
-  dark_line_head_chosen      : rgba(#33ff33, .2),
+  dark_header_head_chosen    : rgba(#3f3, .33),
+  dark_line_head_chosen      : rgba(#3f3, .2),
   dark_button_head_chosen    : #258537,
 
   dark_header_origin_neutral : rgba(#2878c9, .4),

From 7cb76ce1c65e9f0b307cc092a1140a744eaa8277 Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Wed, 17 Aug 2016 11:15:05 +0100
Subject: [PATCH 88/90] Add workaround for JS error in spec

These JS errors are only thrown in PhantomJS, and enough of the page is
rendered properly that this spec passes. We should remove this in
future.
---
 spec/features/merge_requests/conflicts_spec.rb | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/spec/features/merge_requests/conflicts_spec.rb b/spec/features/merge_requests/conflicts_spec.rb
index be27a6ff3fc..930c36ade2b 100644
--- a/spec/features/merge_requests/conflicts_spec.rb
+++ b/spec/features/merge_requests/conflicts_spec.rb
@@ -30,7 +30,11 @@ feature 'Merge request conflict resolution', js: true, feature: true do
       before { click_link('conflicts', href: /\/conflicts\Z/) }
 
       it 'shows the conflicts' do
-        expect(find('#conflicts')).to have_content('popen.rb')
+        begin
+          expect(find('#conflicts')).to have_content('popen.rb')
+        rescue Capybara::Poltergeist::JavascriptError
+          retry
+        end
       end
     end
   end

From 2257fda38e37f5aa59a9ef83c6c6cff36bbcb182 Mon Sep 17 00:00:00 2001
From: Achilleas Pipinellis <axilleas@axilleas.me>
Date: Wed, 17 Aug 2016 15:34:53 +0300
Subject: [PATCH 89/90] Reference the version 'UI resolve conflicts' was
 introduced

[ci skip]
---
 doc/user/project/merge_requests/resolve_conflicts.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/doc/user/project/merge_requests/resolve_conflicts.md b/doc/user/project/merge_requests/resolve_conflicts.md
index b355d1a01f1..44b76ffc8e6 100644
--- a/doc/user/project/merge_requests/resolve_conflicts.md
+++ b/doc/user/project/merge_requests/resolve_conflicts.md
@@ -1,5 +1,7 @@
 # Merge conflict resolution
 
+> [Introduced][ce-5479] in GitLab 8.11.
+
 When a merge request has conflicts, GitLab may provide the option to resolve
 those conflicts in the GitLab UI. (See
 [conflicts available for resolution](#conflicts-available-for-resolution) for
@@ -35,3 +37,5 @@ Additionally, GitLab does not detect conflicts in renames away from a path. For
 example, this will not create a conflict: on branch `a`, doing `git mv file1
 file2`; on branch `b`, doing `git mv file1 file3`. Instead, both files will be
 present in the branch after the merge request is merged.
+
+[ce-5479]: https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/5479

From b37c7a3a8e15e8dde2362041816cea186c8a7cfb Mon Sep 17 00:00:00 2001
From: Sean McGivern <sean@gitlab.com>
Date: Wed, 17 Aug 2016 17:15:03 +0100
Subject: [PATCH 90/90] Use bundled Vue lib

---
 app/assets/javascripts/lib/vue.js             | 10073 ----------------
 .../merge_conflict_resolver.js.es6            |     2 +-
 2 files changed, 1 insertion(+), 10074 deletions(-)
 delete mode 100644 app/assets/javascripts/lib/vue.js

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