text: /*!
   * Select2 4.0.0
   * https://select2.github.io
   *
   * Released under the MIT license
   * https://github.com/select2/select2/blob/master/LICENSE.md
   */
  (function (factory) {
    if (typeof define === 'function' && define.amd) {
      // AMD. Register as an anonymous module.
      define(['jquery'], factory);
    } else if (typeof exports === 'object') {
      // Node/CommonJS
      factory(require('jquery'));
    } else {
      // Browser globals
      factory(jQuery);
    }
  }(function (jQuery) {
    // This is needed so we can catch the AMD loader configuration and use it
    // The inner file should be wrapped (by `banner.start.js`) in a function that
    // returns the AMD loader references.
    var S2 =
  (function () {
    // Restore the Select2 AMD loader so it can be used
    // Needed mostly in the language files, where the loader is not inserted
    if (jQuery && jQuery.fn && jQuery.fn.select2 && jQuery.fn.select2.amd) {
      var S2 = jQuery.fn.select2.amd;
    }
  var S2;(function () { if (!S2 || !S2.requirejs) {
  if (!S2) { S2 = {}; } else { require = S2; }
  /**
   * @license almond 0.2.9 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved.
   * Available via the MIT or new BSD license.
   * see: http://github.com/jrburke/almond for details
   */
  //Going sloppy to avoid 'use strict' string cost, but strict practices should
  //be followed.
  /*jslint sloppy: true */
  /*global setTimeout: false */
  
  var requirejs, require, define;
  (function (undef) {
      var main, req, makeMap, handlers,
          defined = {},
          waiting = {},
          config = {},
          defining = {},
          hasOwn = Object.prototype.hasOwnProperty,
          aps = [].slice,
          jsSuffixRegExp = /\.js$/;
  
      function hasProp(obj, prop) {
          return hasOwn.call(obj, prop);
      }
  
      /**
       * Given a relative module name, like ./something, normalize it to
       * a real name that can be mapped to a path.
       * @param {String} name the relative name
       * @param {String} baseName a real name that the name arg is relative
       * to.
       * @returns {String} normalized name
       */
      function normalize(name, baseName) {
          var nameParts, nameSegment, mapValue, foundMap, lastIndex,
              foundI, foundStarMap, starI, i, j, part,
              baseParts = baseName && baseName.split("/"),
              map = config.map,
              starMap = (map && map['*']) || {};
  
          //Adjust any relative paths.
          if (name && name.charAt(0) === ".") {
              //If have a base name, try to normalize against it,
              //otherwise, assume it is a top-level require that will
              //be relative to baseUrl in the end.
              if (baseName) {
                  //Convert baseName to array, and lop off the last part,
                  //so that . matches that "directory" and not name of the baseName's
                  //module. For instance, baseName of "one/two/three", maps to
                  //"one/two/three.js", but we want the directory, "one/two" for
                  //this normalization.
                  baseParts = baseParts.slice(0, baseParts.length - 1);
                  name = name.split('/');
                  lastIndex = name.length - 1;
  
                  // Node .js allowance:
                  if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
                      name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
                  }
  
                  name = baseParts.concat(name);
  
                  //start trimDots
                  for (i = 0; i < name.length; i += 1) {
                      part = name[i];
                      if (part === ".") {
                          name.splice(i, 1);
                          i -= 1;
                      } else if (part === "..") {
                          if (i === 1 && (name[2] === '..' || name[0] === '..')) {
                              //End of the line. Keep at least one non-dot
                              //path segment at the front so it can be mapped
                              //correctly to disk. Otherwise, there is likely
                              //no path mapping for a path starting with '..'.
                              //This can still fail, but catches the most reasonable
                              //uses of ..
                              break;
                          } else if (i > 0) {
                              name.splice(i - 1, 2);
                              i -= 2;
                          }
                      }
                  }
                  //end trimDots
  
                  name = name.join("/");
              } else if (name.indexOf('./') === 0) {
                  // No baseName, so this is ID is resolved relative
                  // to baseUrl, pull off the leading dot.
                  name = name.substring(2);
              }
          }
  
          //Apply map config if available.
          if ((baseParts || starMap) && map) {
              nameParts = name.split('/');
  
              for (i = nameParts.length; i > 0; i -= 1) {
                  nameSegment = nameParts.slice(0, i).join("/");
  
                  if (baseParts) {
                      //Find the longest baseName segment match in the config.
                      //So, do joins on the biggest to smallest lengths of baseParts.
                      for (j = baseParts.length; j > 0; j -= 1) {
                          mapValue = map[baseParts.slice(0, j).join('/')];
  
                          //baseName segment has  config, find if it has one for
                          //this name.
                          if (mapValue) {
                              mapValue = mapValue[nameSegment];
                              if (mapValue) {
                                  //Match, update name to the new value.
                                  foundMap = mapValue;
                                  foundI = i;
                                  break;
                              }
                          }
                      }
                  }
  
                  if (foundMap) {
                      break;
                  }
  
                  //Check for a star map match, but just hold on to it,
                  //if there is a shorter segment match later in a matching
                  //config, then favor over this star map.
                  if (!foundStarMap && starMap && starMap[nameSegment]) {
                      foundStarMap = starMap[nameSegment];
                      starI = i;
                  }
              }
  
              if (!foundMap && foundStarMap) {
                  foundMap = foundStarMap;
                  foundI = starI;
              }
  
              if (foundMap) {
                  nameParts.splice(0, foundI, foundMap);
                  name = nameParts.join('/');
              }
          }
  
          return name;
      }
  
      function makeRequire(relName, forceSync) {
          return function () {
              //A version of a require function that passes a moduleName
              //value for items that may need to
              //look up paths relative to the moduleName
              return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync]));
          };
      }
  
      function makeNormalize(relName) {
          return function (name) {
              return normalize(name, relName);
          };
      }
  
      function makeLoad(depName) {
          return function (value) {
              defined[depName] = value;
          };
      }
  
      function callDep(name) {
          if (hasProp(waiting, name)) {
              var args = waiting[name];
              delete waiting[name];
              defining[name] = true;
              main.apply(undef, args);
          }
  
          if (!hasProp(defined, name) && !hasProp(defining, name)) {
              throw new Error('No ' + name);
          }
          return defined[name];
      }
  
      //Turns a plugin!resource to [plugin, resource]
      //with the plugin being undefined if the name
      //did not have a plugin prefix.
      function splitPrefix(name) {
          var prefix,
              index = name ? name.indexOf('!') : -1;
          if (index > -1) {
              prefix = name.substring(0, index);
              name = name.substring(index + 1, name.length);
          }
          return [prefix, name];
      }
  
      /**
       * Makes a name map, normalizing the name, and using a plugin
       * for normalization if necessary. Grabs a ref to plugin
       * too, as an optimization.
       */
      makeMap = function (name, relName) {
          var plugin,
              parts = splitPrefix(name),
              prefix = parts[0];
  
          name = parts[1];
  
          if (prefix) {
              prefix = normalize(prefix, relName);
              plugin = callDep(prefix);
          }
  
          //Normalize according
          if (prefix) {
              if (plugin && plugin.normalize) {
                  name = plugin.normalize(name, makeNormalize(relName));
              } else {
                  name = normalize(name, relName);
              }
          } else {
              name = normalize(name, relName);
              parts = splitPrefix(name);
              prefix = parts[0];
              name = parts[1];
              if (prefix) {
                  plugin = callDep(prefix);
              }
          }
  
          //Using ridiculous property names for space reasons
          return {
              f: prefix ? prefix + '!' + name : name, //fullName
              n: name,
              pr: prefix,
              p: plugin
          };
      };
  
      function makeConfig(name) {
          return function () {
              return (config && config.config && config.config[name]) || {};
          };
      }
  
      handlers = {
          require: function (name) {
              return makeRequire(name);
          },
          exports: function (name) {
              var e = defined[name];
              if (typeof e !== 'undefined') {
                  return e;
              } else {
                  return (defined[name] = {});
              }
          },
          module: function (name) {
              return {
                  id: name,
                  uri: '',
                  exports: defined[name],
                  config: makeConfig(name)
              };
          }
      };
  
      main = function (name, deps, callback, relName) {
          var cjsModule, depName, ret, map, i,
              args = [],
              callbackType = typeof callback,
              usingExports;
  
          //Use name if no relName
          relName = relName || name;
  
          //Call the callback to define the module, if necessary.
          if (callbackType === 'undefined' || callbackType === 'function') {
              //Pull out the defined dependencies and pass the ordered
              //values to the callback.
              //Default to [require, exports, module] if no deps
              deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
              for (i = 0; i < deps.length; i += 1) {
                  map = makeMap(deps[i], relName);
                  depName = map.f;
  
                  //Fast path CommonJS standard dependencies.
                  if (depName === "require") {
                      args[i] = handlers.require(name);
                  } else if (depName === "exports") {
                      //CommonJS module spec 1.1
                      args[i] = handlers.exports(name);
                      usingExports = true;
                  } else if (depName === "module") {
                      //CommonJS module spec 1.1
                      cjsModule = args[i] = handlers.module(name);
                  } else if (hasProp(defined, depName) ||
                             hasProp(waiting, depName) ||
                             hasProp(defining, depName)) {
                      args[i] = callDep(depName);
                  } else if (map.p) {
                      map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
                      args[i] = defined[depName];
                  } else {
                      throw new Error(name + ' missing ' + depName);
                  }
              }
  
              ret = callback ? callback.apply(defined[name], args) : undefined;
  
              if (name) {
                  //If setting exports via "module" is in play,
                  //favor that over return value and exports. After that,
                  //favor a non-undefined return value over exports use.
                  if (cjsModule && cjsModule.exports !== undef &&
                          cjsModule.exports !== defined[name]) {
                      defined[name] = cjsModule.exports;
                  } else if (ret !== undef || !usingExports) {
                      //Use the return value from the function.
                      defined[name] = ret;
                  }
              }
          } else if (name) {
              //May just be an object definition for the module. Only
              //worry about defining if have a module name.
              defined[name] = callback;
          }
      };
  
      requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
          if (typeof deps === "string") {
              if (handlers[deps]) {
                  //callback in this case is really relName
                  return handlers[deps](callback);
              }
              //Just return the module wanted. In this scenario, the
              //deps arg is the module name, and second arg (if passed)
              //is just the relName.
              //Normalize module name, if it contains . or ..
              return callDep(makeMap(deps, callback).f);
          } else if (!deps.splice) {
              //deps is a config object, not an array.
              config = deps;
              if (config.deps) {
                  req(config.deps, config.callback);
              }
              if (!callback) {
                  return;
              }
  
              if (callback.splice) {
                  //callback is an array, which means it is a dependency list.
                  //Adjust args if there are dependencies
                  deps = callback;
                  callback = relName;
                  relName = null;
              } else {
                  deps = undef;
              }
          }
  
          //Support require(['a'])
          callback = callback || function () {};
  
          //If relName is a function, it is an errback handler,
          //so remove it.
          if (typeof relName === 'function') {
              relName = forceSync;
              forceSync = alt;
          }
  
          //Simulate async callback;
          if (forceSync) {
              main(undef, deps, callback, relName);
          } else {
              //Using a non-zero value because of concern for what old browsers
              //do, and latest browsers "upgrade" to 4 if lower value is used:
              //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
              //If want a value immediately, use require('id') instead -- something
              //that works in almond on the global level, but not guaranteed and
              //unlikely to work in other AMD implementations.
              setTimeout(function () {
                  main(undef, deps, callback, relName);
              }, 4);
          }
  
          return req;
      };
  
      /**
       * Just drops the config on the floor, but returns req in case
       * the config return value is used.
       */
      req.config = function (cfg) {
          return req(cfg);
      };
  
      /**
       * Expose module registry for debugging and tooling
       */
      requirejs._defined = defined;
  
      define = function (name, deps, callback) {
  
          //This module may not have dependencies
          if (!deps.splice) {
              //deps is not an array, so probably means
              //an object literal or factory function for
              //the value. Adjust args.
              callback = deps;
              deps = [];
          }
  
          if (!hasProp(defined, name) && !hasProp(waiting, name)) {
              waiting[name] = [name, deps, callback];
          }
      };
  
      define.amd = {
          jQuery: true
      };
  }());
  
  S2.requirejs = requirejs;S2.require = require;S2.define = define;
  }
  }());
  S2.define("almond", function(){});
  
  /* global jQuery:false, $:false */
  S2.define('jquery',[],function () {
    var _$ = jQuery || $;
  
    if (_$ == null && console && console.error) {
      console.error(
        'Select2: An instance of jQuery or a jQuery-compatible library was not ' +
        'found. Make sure that you are including jQuery before Select2 on your ' +
        'web page.'
      );
    }
  
    return _$;
  });
  
  S2.define('select2/utils',[
    'jquery'
  ], function ($) {
    var Utils = {};
  
    Utils.Extend = function (ChildClass, SuperClass) {
      var __hasProp = {}.hasOwnProperty;
  
      function BaseConstructor () {
        this.constructor = ChildClass;
      }
  
      for (var key in SuperClass) {
        if (__hasProp.call(SuperClass, key)) {
          ChildClass[key] = SuperClass[key];
        }
      }
  
      BaseConstructor.prototype = SuperClass.prototype;
      ChildClass.prototype = new BaseConstructor();
      ChildClass.__super__ = SuperClass.prototype;
  
      return ChildClass;
    };
  
    function getMethods (theClass) {
      var proto = theClass.prototype;
  
      var methods = [];
  
      for (var methodName in proto) {
        var m = proto[methodName];
  
        if (typeof m !== 'function') {
          continue;
        }
  
        if (methodName === 'constructor') {
          continue;
        }
  
        methods.push(methodName);
      }
  
      return methods;
    }
  
    Utils.Decorate = function (SuperClass, DecoratorClass) {
      var decoratedMethods = getMethods(DecoratorClass);
      var superMethods = getMethods(SuperClass);
  
      function DecoratedClass () {
        var unshift = Array.prototype.unshift;
  
        var argCount = DecoratorClass.prototype.constructor.length;
  
        var calledConstructor = SuperClass.prototype.constructor;
  
        if (argCount > 0) {
          unshift.call(arguments, SuperClass.prototype.constructor);
  
          calledConstructor = DecoratorClass.prototype.constructor;
        }
  
        calledConstructor.apply(this, arguments);
      }
  
      DecoratorClass.displayName = SuperClass.displayName;
  
      function ctr () {
        this.constructor = DecoratedClass;
      }
  
      DecoratedClass.prototype = new ctr();
  
      for (var m = 0; m < superMethods.length; m++) {
          var superMethod = superMethods[m];
  
          DecoratedClass.prototype[superMethod] =
            SuperClass.prototype[superMethod];
      }
  
      var calledMethod = function (methodName) {
        // Stub out the original method if it's not decorating an actual method
        var originalMethod = function () {};
  
        if (methodName in DecoratedClass.prototype) {
          originalMethod = DecoratedClass.prototype[methodName];
        }
  
        var decoratedMethod = DecoratorClass.prototype[methodName];
  
        return function () {
          var unshift = Array.prototype.unshift;
  
          unshift.call(arguments, originalMethod);
  
          return decoratedMethod.apply(this, arguments);
        };
      };
  
      for (var d = 0; d < decoratedMethods.length; d++) {
        var decoratedMethod = decoratedMethods[d];
  
        DecoratedClass.prototype[decoratedMethod] = calledMethod(decoratedMethod);
      }
  
      return DecoratedClass;
    };
  
    var Observable = function () {
      this.listeners = {};
    };
  
    Observable.prototype.on = function (event, callback) {
      this.listeners = this.listeners || {};
  
      if (event in this.listeners) {
        this.listeners[event].push(callback);
      } else {
        this.listeners[event] = [callback];
      }
    };
  
    Observable.prototype.trigger = function (event) {
      var slice = Array.prototype.slice;
  
      this.listeners = this.listeners || {};
  
      if (event in this.listeners) {
        this.invoke(this.listeners[event], slice.call(arguments, 1));
      }
  
      if ('*' in this.listeners) {
        this.invoke(this.listeners['*'], arguments);
      }
    };
  
    Observable.prototype.invoke = function (listeners, params) {
      for (var i = 0, len = listeners.length; i < len; i++) {
        listeners[i].apply(this, params);
      }
    };
  
    Utils.Observable = Observable;
  
    Utils.generateChars = function (length) {
      var chars = '';
  
      for (var i = 0; i < length; i++) {
        var randomChar = Math.floor(Math.random() * 36);
        chars += randomChar.toString(36);
      }
  
      return chars;
    };
  
    Utils.bind = function (func, context) {
      return function () {
        func.apply(context, arguments);
      };
    };
  
    Utils._convertData = function (data) {
      for (var originalKey in data) {
        var keys = originalKey.split('-');
  
        var dataLevel = data;
  
        if (keys.length === 1) {
          continue;
        }
  
        for (var k = 0; k < keys.length; k++) {
          var key = keys[k];
  
          // Lowercase the first letter
          // By default, dash-separated becomes camelCase
          key = key.substring(0, 1).toLowerCase() + key.substring(1);
  
          if (!(key in dataLevel)) {
            dataLevel[key] = {};
          }
  
          if (k == keys.length - 1) {
            dataLevel[key] = data[originalKey];
          }
  
          dataLevel = dataLevel[key];
        }
  
        delete data[originalKey];
      }
  
      return data;
    };
  
    Utils.hasScroll = function (index, el) {
      // Adapted from the function created by @ShadowScripter
      // and adapted by @BillBarry on the Stack Exchange Code Review website.
      // The original code can be found at
      // http://codereview.stackexchange.com/q/13338
      // and was designed to be used with the Sizzle selector engine.
  
      var $el = $(el);
      var overflowX = el.style.overflowX;
      var overflowY = el.style.overflowY;
  
      //Check both x and y declarations
      if (overflowX === overflowY &&
          (overflowY === 'hidden' || overflowY === 'visible')) {
        return false;
      }
  
      if (overflowX === 'scroll' || overflowY === 'scroll') {
        return true;
      }
  
      return ($el.innerHeight() < el.scrollHeight ||
        $el.innerWidth() < el.scrollWidth);
    };
  
    Utils.escapeMarkup = function (markup) {
      var replaceMap = {
        '\\': '&#92;',
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',
        '\'': '&#39;',
        '/': '&#47;'
      };
  
      // Do not try to escape the markup if it's not a string
      if (typeof markup !== 'string') {
        return markup;
      }
  
      return String(markup).replace(/[&<>"'\/\\]/g, function (match) {
        return replaceMap[match];
      });
    };
  
    // Append an array of jQuery nodes to a given element.
    Utils.appendMany = function ($element, $nodes) {
      // jQuery 1.7.x does not support $.fn.append() with an array
      // Fall back to a jQuery object collection using $.fn.add()
      if ($.fn.jquery.substr(0, 3) === '1.7') {
        var $jqNodes = $();
  
        $.map($nodes, function (node) {
          $jqNodes = $jqNodes.add(node);
        });
  
        $nodes = $jqNodes;
      }
  
      $element.append($nodes);
    };
  
    return Utils;
  });
  
  S2.define('select2/results',[
    'jquery',
    './utils'
  ], function ($, Utils) {
    function Results ($element, options, dataAdapter) {
      this.$element = $element;
      this.data = dataAdapter;
      this.options = options;
  
      Results.__super__.constructor.call(this);
    }
  
    Utils.Extend(Results, Utils.Observable);
  
    Results.prototype.render = function () {
      var $results = $(
        '<ul class="select2-results__options" role="tree"></ul>'
      );
  
      if (this.options.get('multiple')) {
        $results.attr('aria-multiselectable', 'true');
      }
  
      this.$results = $results;
  
      return $results;
    };
  
    Results.prototype.clear = function () {
      this.$results.empty();
    };
  
    Results.prototype.displayMessage = function (params) {
      var escapeMarkup = this.options.get('escapeMarkup');
  
      this.clear();
      this.hideLoading();
  
      var $message = $(
        '<li role="treeitem" class="select2-results__option"></li>'
      );
  
      var message = this.options.get('translations').get(params.message);
  
      $message.append(
        escapeMarkup(
          message(params.args)
        )
      );
  
      this.$results.append($message);
    };
  
    Results.prototype.append = function (data) {
      this.hideLoading();
  
      var $options = [];
  
      if (data.results == null || data.results.length === 0) {
        if (this.$results.children().length === 0) {
          this.trigger('results:message', {
            message: 'noResults'
          });
        }
  
        return;
      }
  
      data.results = this.sort(data.results);
  
      for (var d = 0; d < data.results.length; d++) {
        var item = data.results[d];
  
        var $option = this.option(item);
  
        $options.push($option);
      }
  
      this.$results.append($options);
    };
  
    Results.prototype.position = function ($results, $dropdown) {
      var $resultsContainer = $dropdown.find('.select2-results');
      $resultsContainer.append($results);
    };
  
    Results.prototype.sort = function (data) {
      var sorter = this.options.get('sorter');
  
      return sorter(data);
    };
  
    Results.prototype.setClasses = function () {
      var self = this;
  
      this.data.current(function (selected) {
        var selectedIds = $.map(selected, function (s) {
          return s.id.toString();
        });
  
        var $options = self.$results
          .find('.select2-results__option[aria-selected]');
  
        $options.each(function () {
          var $option = $(this);
  
          var item = $.data(this, 'data');
  
          // id needs to be converted to a string when comparing
          var id = '' + item.id;
  
          if ((item.element != null && item.element.selected) ||
              (item.element == null && $.inArray(id, selectedIds) > -1)) {
            $option.attr('aria-selected', 'true');
          } else {
            $option.attr('aria-selected', 'false');
          }
        });
  
        var $selected = $options.filter('[aria-selected=true]');
  
        // Check if there are any selected options
        if ($selected.length > 0) {
          // If there are selected options, highlight the first
          $selected.first().trigger('mouseenter');
        } else {
          // If there are no selected options, highlight the first option
          // in the dropdown
          $options.first().trigger('mouseenter');
        }
      });
    };
  
    Results.prototype.showLoading = function (params) {
      this.hideLoading();
  
      var loadingMore = this.options.get('translations').get('searching');
  
      var loading = {
        disabled: true,
        loading: true,
        text: loadingMore(params)
      };
      var $loading = this.option(loading);
      $loading.className += ' loading-results';
  
      this.$results.prepend($loading);
    };
  
    Results.prototype.hideLoading = function () {
      this.$results.find('.loading-results').remove();
    };
  
    Results.prototype.option = function (data) {
      var option = document.createElement('li');
      option.className = 'select2-results__option';
  
      var attrs = {
        'role': 'treeitem',
        'aria-selected': 'false'
      };
  
      if (data.disabled) {
        delete attrs['aria-selected'];
        attrs['aria-disabled'] = 'true';
      }
  
      if (data.id == null) {
        delete attrs['aria-selected'];
      }
  
      if (data._resultId != null) {
        option.id = data._resultId;
      }
  
      if (data.title) {
        option.title = data.title;
      }
  
      if (data.children) {
        attrs.role = 'group';
        attrs['aria-label'] = data.text;
        delete attrs['aria-selected'];
      }
  
      for (var attr in attrs) {
        var val = attrs[attr];
  
        option.setAttribute(attr, val);
      }
  
      if (data.children) {
        var $option = $(option);
  
        var label = document.createElement('strong');
        label.className = 'select2-results__group';
  
        var $label = $(label);
        this.template(data, label);
  
        var $children = [];
  
        for (var c = 0; c < data.children.length; c++) {
          var child = data.children[c];
  
          var $child = this.option(child);
  
          $children.push($child);
        }
  
        var $childrenContainer = $('<ul></ul>', {
          'class': 'select2-results__options select2-results__options--nested'
        });
  
        $childrenContainer.append($children);
  
        $option.append(label);
        $option.append($childrenContainer);
      } else {
        this.template(data, option);
      }
  
      $.data(option, 'data', data);
  
      return option;
    };
  
    Results.prototype.bind = function (container, $container) {
      var self = this;
  
      var id = container.id + '-results';
  
      this.$results.attr('id', id);
  
      container.on('results:all', function (params) {
        self.clear();
        self.append(params.data);
  
        if (container.isOpen()) {
          self.setClasses();
        }
      });
  
      container.on('results:append', function (params) {
        self.append(params.data);
  
        if (container.isOpen()) {
          self.setClasses();
        }
      });
  
      container.on('query', function (params) {
        self.showLoading(params);
      });
  
      container.on('select', function () {
        if (!container.isOpen()) {
          return;
        }
  
        self.setClasses();
      });
  
      container.on('unselect', function () {
        if (!container.isOpen()) {
          return;
        }
  
        self.setClasses();
      });
  
      container.on('open', function () {
        // When the dropdown is open, aria-expended="true"
        self.$results.attr('aria-expanded', 'true');
        self.$results.attr('aria-hidden', 'false');
  
        self.setClasses();
        self.ensureHighlightVisible();
      });
  
      container.on('close', function () {
        // When the dropdown is closed, aria-expended="false"
        self.$results.attr('aria-expanded', 'false');
        self.$results.attr('aria-hidden', 'true');
        self.$results.removeAttr('aria-activedescendant');
      });
  
      container.on('results:toggle', function () {
        var $highlighted = self.getHighlightedResults();
  
        if ($highlighted.length === 0) {
          return;
        }
  
        $highlighted.trigger('mouseup');
      });
  
      container.on('results:select', function () {
        var $highlighted = self.getHighlightedResults();
  
        if ($highlighted.length === 0) {
          return;
        }
  
        var data = $highlighted.data('data');
  
        if ($highlighted.attr('aria-selected') == 'true') {
          self.trigger('close');
        } else {
          self.trigger('select', {
            data: data
          });
        }
      });
  
      container.on('results:previous', function () {
        var $highlighted = self.getHighlightedResults();
  
        var $options = self.$results.find('[aria-selected]');
  
        var currentIndex = $options.index($highlighted);
  
        // If we are already at te top, don't move further
        if (currentIndex === 0) {
          return;
        }
  
        var nextIndex = currentIndex - 1;
  
        // If none are highlighted, highlight the first
        if ($highlighted.length === 0) {
          nextIndex = 0;
        }
  
        var $next = $options.eq(nextIndex);
  
        $next.trigger('mouseenter');
  
        var currentOffset = self.$results.offset().top;
        var nextTop = $next.offset().top;
        var nextOffset = self.$results.scrollTop() + (nextTop - currentOffset);
  
        if (nextIndex === 0) {
          self.$results.scrollTop(0);
        } else if (nextTop - currentOffset < 0) {
          self.$results.scrollTop(nextOffset);
        }
      });
  
      container.on('results:next', function () {
        var $highlighted = self.getHighlightedResults();
  
        var $options = self.$results.find('[aria-selected]');
  
        var currentIndex = $options.index($highlighted);
  
        var nextIndex = currentIndex + 1;
  
        // If we are at the last option, stay there
        if (nextIndex >= $options.length) {
          return;
        }
  
        var $next = $options.eq(nextIndex);
  
        $next.trigger('mouseenter');
  
        var currentOffset = self.$results.offset().top +
          self.$results.outerHeight(false);
        var nextBottom = $next.offset().top + $next.outerHeight(false);
        var nextOffset = self.$results.scrollTop() + nextBottom - currentOffset;
  
        if (nextIndex === 0) {
          self.$results.scrollTop(0);
        } else if (nextBottom > currentOffset) {
          self.$results.scrollTop(nextOffset);
        }
      });
  
      container.on('results:focus', function (params) {
        params.element.addClass('select2-results__option--highlighted');
      });
  
      container.on('results:message', function (params) {
        self.displayMessage(params);
      });
  
      if ($.fn.mousewheel) {
        this.$results.on('mousewheel', function (e) {
          var top = self.$results.scrollTop();
  
          var bottom = (
            self.$results.get(0).scrollHeight -
            self.$results.scrollTop() +
            e.deltaY
          );
  
          var isAtTop = e.deltaY > 0 && top - e.deltaY <= 0;
          var isAtBottom = e.deltaY < 0 && bottom <= self.$results.height();
  
          if (isAtTop) {
            self.$results.scrollTop(0);
  
            e.preventDefault();
            e.stopPropagation();
          } else if (isAtBottom) {
            self.$results.scrollTop(
              self.$results.get(0).scrollHeight - self.$results.height()
            );
  
            e.preventDefault();
            e.stopPropagation();
          }
        });
      }
  
      this.$results.on('mouseup', '.select2-results__option[aria-selected]',
        function (evt) {
        var $this = $(this);
  
        var data = $this.data('data');
  
        if ($this.attr('aria-selected') === 'true') {
          if (self.options.get('multiple')) {
            self.trigger('unselect', {
              originalEvent: evt,
              data: data
            });
          } else {
            self.trigger('close');
          }
  
          return;
        }
  
        self.trigger('select', {
          originalEvent: evt,
          data: data
        });
      });
  
      this.$results.on('mouseenter', '.select2-results__option[aria-selected]',
        function (evt) {
        var data = $(this).data('data');
  
        self.getHighlightedResults()
            .removeClass('select2-results__option--highlighted');
  
        self.trigger('results:focus', {
          data: data,
          element: $(this)
        });
      });
    };
  
    Results.prototype.getHighlightedResults = function () {
      var $highlighted = this.$results
      .find('.select2-results__option--highlighted');
  
      return $highlighted;
    };
  
    Results.prototype.destroy = function () {
      this.$results.remove();
    };
  
    Results.prototype.ensureHighlightVisible = function () {
      var $highlighted = this.getHighlightedResults();
  
      if ($highlighted.length === 0) {
        return;
      }
  
      var $options = this.$results.find('[aria-selected]');
  
      var currentIndex = $options.index($highlighted);
  
      var currentOffset = this.$results.offset().top;
      var nextTop = $highlighted.offset().top;
      var nextOffset = this.$results.scrollTop() + (nextTop - currentOffset);
  
      var offsetDelta = nextTop - currentOffset;
      nextOffset -= $highlighted.outerHeight(false) * 2;
  
      if (currentIndex <= 2) {
        this.$results.scrollTop(0);
      } else if (offsetDelta > this.$results.outerHeight() || offsetDelta < 0) {
        this.$results.scrollTop(nextOffset);
      }
    };
  
    Results.prototype.template = function (result, container) {
      var template = this.options.get('templateResult');
      var escapeMarkup = this.options.get('escapeMarkup');
  
      var content = template(result);
  
      if (content == null) {
        container.style.display = 'none';
      } else if (typeof content === 'string') {
        container.innerHTML = escapeMarkup(content);
      } else {
        $(container).append(content);
      }
    };
  
    return Results;
  });
  
  S2.define('select2/keys',[
  
  ], function () {
    var KEYS = {
      BACKSPACE: 8,
      TAB: 9,
      ENTER: 13,
      SHIFT: 16,
      CTRL: 17,
      ALT: 18,
      ESC: 27,
      SPACE: 32,
      PAGE_UP: 33,
      PAGE_DOWN: 34,
      END: 35,
      HOME: 36,
      LEFT: 37,
      UP: 38,
      RIGHT: 39,
      DOWN: 40,
      DELETE: 46
    };
  
    return KEYS;
  });
  
  S2.define('select2/selection/base',[
    'jquery',
    '../utils',
    '../keys'
  ], function ($, Utils, KEYS) {
    function BaseSelection ($element, options) {
      this.$element = $element;
      this.options = options;
  
      BaseSelection.__super__.constructor.call(this);
    }
  
    Utils.Extend(BaseSelection, Utils.Observable);
  
    BaseSelection.prototype.render = function () {
      var $selection = $(
        '<span class="select2-selection" role="combobox" ' +
        'aria-autocomplete="list" aria-haspopup="true" aria-expanded="false">' +
        '</span>'
      );
  
      this._tabindex = 0;
  
      if (this.$element.data('old-tabindex') != null) {
        this._tabindex = this.$element.data('old-tabindex');
      } else if (this.$element.attr('tabindex') != null) {
        this._tabindex = this.$element.attr('tabindex');
      }
  
      $selection.attr('title', this.$element.attr('title'));
      $selection.attr('tabindex', this._tabindex);
  
      this.$selection = $selection;
  
      return $selection;
    };
  
    BaseSelection.prototype.bind = function (container, $container) {
      var self = this;
  
      var id = container.id + '-container';
      var resultsId = container.id + '-results';
  
      this.container = container;
  
      this.$selection.on('focus', function (evt) {
        self.trigger('focus', evt);
      });
  
      this.$selection.on('blur', function (evt) {
        self.trigger('blur', evt);
      });
  
      this.$selection.on('keydown', function (evt) {
        self.trigger('keypress', evt);
  
        if (evt.which === KEYS.SPACE) {
          evt.preventDefault();
        }
      });
  
      container.on('results:focus', function (params) {
        self.$selection.attr('aria-activedescendant', params.data._resultId);
      });
  
      container.on('selection:update', function (params) {
        self.update(params.data);
      });
  
      container.on('open', function () {
        // When the dropdown is open, aria-expanded="true"
        self.$selection.attr('aria-expanded', 'true');
        self.$selection.attr('aria-owns', resultsId);
  
        self._attachCloseHandler(container);
      });
  
      container.on('close', function () {
        // When the dropdown is closed, aria-expanded="false"
        self.$selection.attr('aria-expanded', 'false');
        self.$selection.removeAttr('aria-activedescendant');
        self.$selection.removeAttr('aria-owns');
  
        self.$selection.focus();
  
        self._detachCloseHandler(container);
      });
  
      container.on('enable', function () {
        self.$selection.attr('tabindex', self._tabindex);
      });
  
      container.on('disable', function () {
        self.$selection.attr('tabindex', '-1');
      });
    };
  
    BaseSelection.prototype._attachCloseHandler = function (container) {
      var self = this;
  
      $(document.body).on('mousedown.select2.' + container.id, function (e) {
        var $target = $(e.target);
  
        var $select = $target.closest('.select2');
  
        var $all = $('.select2.select2-container--open');
  
        $all.each(function () {
          var $this = $(this);
  
          if (this == $select[0]) {
            return;
          }
  
          var $element = $this.data('element');
  
          $element.select2('close');
        });
      });
    };
  
    BaseSelection.prototype._detachCloseHandler = function (container) {
      $(document.body).off('mousedown.select2.' + container.id);
    };
  
    BaseSelection.prototype.position = function ($selection, $container) {
      var $selectionContainer = $container.find('.selection');
      $selectionContainer.append($selection);
    };
  
    BaseSelection.prototype.destroy = function () {
      this._detachCloseHandler(this.container);
    };
  
    BaseSelection.prototype.update = function (data) {
      throw new Error('The `update` method must be defined in child classes.');
    };
  
    return BaseSelection;
  });
  
  S2.define('select2/selection/single',[
    'jquery',
    './base',
    '../utils',
    '../keys'
  ], function ($, BaseSelection, Utils, KEYS) {
    function SingleSelection () {
      SingleSelection.__super__.constructor.apply(this, arguments);
    }
  
    Utils.Extend(SingleSelection, BaseSelection);
  
    SingleSelection.prototype.render = function () {
      var $selection = SingleSelection.__super__.render.call(this);
  
      $selection.addClass('select2-selection--single');
  
      $selection.html(
        '<span class="select2-selection__rendered"></span>' +
        '<span class="select2-selection__arrow" role="presentation">' +
          '<b role="presentation"></b>' +
        '</span>'
      );
  
      return $selection;
    };
  
    SingleSelection.prototype.bind = function (container, $container) {
      var self = this;
  
      SingleSelection.__super__.bind.apply(this, arguments);
  
      var id = container.id + '-container';
  
      this.$selection.find('.select2-selection__rendered').attr('id', id);
      this.$selection.attr('aria-labelledby', id);
  
      this.$selection.on('mousedown', function (evt) {
        // Only respond to left clicks
        if (evt.which !== 1) {
          return;
        }
  
        self.trigger('toggle', {
          originalEvent: evt
        });
      });
  
      this.$selection.on('focus', function (evt) {
        // User focuses on the container
      });
  
      this.$selection.on('blur', function (evt) {
        // User exits the container
      });
  
      container.on('selection:update', function (params) {
        self.update(params.data);
      });
    };
  
    SingleSelection.prototype.clear = function () {
      this.$selection.find('.select2-selection__rendered').empty();
    };
  
    SingleSelection.prototype.display = function (data) {
      var template = this.options.get('templateSelection');
      var escapeMarkup = this.options.get('escapeMarkup');
  
      return escapeMarkup(template(data));
    };
  
    SingleSelection.prototype.selectionContainer = function () {
      return $('<span></span>');
    };
  
    SingleSelection.prototype.update = function (data) {
      if (data.length === 0) {
        this.clear();
        return;
      }
  
      var selection = data[0];
  
      var formatted = this.display(selection);
  
      var $rendered = this.$selection.find('.select2-selection__rendered');
      $rendered.empty().append(formatted);
      $rendered.prop('title', selection.title || selection.text);
    };
  
    return SingleSelection;
  });
  
  S2.define('select2/selection/multiple',[
    'jquery',
    './base',
    '../utils'
  ], function ($, BaseSelection, Utils) {
    function MultipleSelection ($element, options) {
      MultipleSelection.__super__.constructor.apply(this, arguments);
    }
  
    Utils.Extend(MultipleSelection, BaseSelection);
  
    MultipleSelection.prototype.render = function () {
      var $selection = MultipleSelection.__super__.render.call(this);
  
      $selection.addClass('select2-selection--multiple');
  
      $selection.html(
        '<ul class="select2-selection__rendered"></ul>'
      );
  
      return $selection;
    };
  
    MultipleSelection.prototype.bind = function (container, $container) {
      var self = this;
  
      MultipleSelection.__super__.bind.apply(this, arguments);
  
      this.$selection.on('click', function (evt) {
        self.trigger('toggle', {
          originalEvent: evt
        });
      });
  
      this.$selection.on('click', '.select2-selection__choice__remove',
        function (evt) {
        var $remove = $(this);
        var $selection = $remove.parent();
  
        var data = $selection.data('data');
  
        self.trigger('unselect', {
          originalEvent: evt,
          data: data
        });
      });
    };
  
    MultipleSelection.prototype.clear = function () {
      this.$selection.find('.select2-selection__rendered').empty();
    };
  
    MultipleSelection.prototype.display = function (data) {
      var template = this.options.get('templateSelection');
      var escapeMarkup = this.options.get('escapeMarkup');
  
      return escapeMarkup(template(data));
    };
  
    MultipleSelection.prototype.selectionContainer = function () {
      var $container = $(
        '<li class="select2-selection__choice">' +
          '<span class="select2-selection__choice__remove" role="presentation">' +
            '&times;' +
          '</span>' +
        '</li>'
      );
  
      return $container;
    };
  
    MultipleSelection.prototype.update = function (data) {
      this.clear();
  
      if (data.length === 0) {
        return;
      }
  
      var $selections = [];
  
      for (var d = 0; d < data.length; d++) {
        var selection = data[d];
  
        var formatted = this.display(selection);
        var $selection = this.selectionContainer();
  
        $selection.append(formatted);
        $selection.prop('title', selection.title || selection.text);
  
        $selection.data('data', selection);
  
        $selections.push($selection);
      }
  
      var $rendered = this.$selection.find('.select2-selection__rendered');
  
      Utils.appendMany($rendered, $selections);
    };
  
    return MultipleSelection;
  });
  
  S2.define('select2/selection/placeholder',[
    '../utils'
  ], function (Utils) {
    function Placeholder (decorated, $element, options) {
      this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
  
      decorated.call(this, $element, options);
    }
  
    Placeholder.prototype.normalizePlaceholder = function (_, placeholder) {
      if (typeof placeholder === 'string') {
        placeholder = {
          id: '',
          text: placeholder
        };
      }
  
      return placeholder;
    };
  
    Placeholder.prototype.createPlaceholder = function (decorated, placeholder) {
      var $placeholder = this.selectionContainer();
  
      $placeholder.html(this.display(placeholder));
      $placeholder.addClass('select2-selection__placeholder')
                  .removeClass('select2-selection__choice');
  
      return $placeholder;
    };
  
    Placeholder.prototype.update = function (decorated, data) {
      var singlePlaceholder = (
        data.length == 1 && data[0].id != this.placeholder.id
      );
      var multipleSelections = data.length > 1;
  
      if (multipleSelections || singlePlaceholder) {
        return decorated.call(this, data);
      }
  
      this.clear();
  
      var $placeholder = this.createPlaceholder(this.placeholder);
  
      this.$selection.find('.select2-selection__rendered').append($placeholder);
    };
  
    return Placeholder;
  });
  
  S2.define('select2/selection/allowClear',[
    'jquery',
    '../keys'
  ], function ($, KEYS) {
    function AllowClear () { }
  
    AllowClear.prototype.bind = function (decorated, container, $container) {
      var self = this;
  
      decorated.call(this, container, $container);
  
      if (this.placeholder == null) {
        if (this.options.get('debug') && window.console && console.error) {
          console.error(
            'Select2: The `allowClear` option should be used in combination ' +
            'with the `placeholder` option.'
          );
        }
      }
  
      this.$selection.on('mousedown', '.select2-selection__clear',
        function (evt) {
          self._handleClear(evt);
      });
  
      container.on('keypress', function (evt) {
        self._handleKeyboardClear(evt, container);
      });
    };
  
    AllowClear.prototype._handleClear = function (_, evt) {
      // Ignore the event if it is disabled
      if (this.options.get('disabled')) {
        return;
      }
  
      var $clear = this.$selection.find('.select2-selection__clear');
  
      // Ignore the event if nothing has been selected
      if ($clear.length === 0) {
        return;
      }
  
      evt.stopPropagation();
  
      var data = $clear.data('data');
  
      for (var d = 0; d < data.length; d++) {
        var unselectData = {
          data: data[d]
        };
  
        // Trigger the `unselect` event, so people can prevent it from being
        // cleared.
        this.trigger('unselect', unselectData);
  
        // If the event was prevented, don't clear it out.
        if (unselectData.prevented) {
          return;
        }
      }
  
      this.$element.val(this.placeholder.id).trigger('change');
  
      this.trigger('toggle');
    };
  
    AllowClear.prototype._handleKeyboardClear = function (_, evt, container) {
      if (container.isOpen()) {
        return;
      }
  
      if (evt.which == KEYS.DELETE || evt.which == KEYS.BACKSPACE) {
        this._handleClear(evt);
      }
    };
  
    AllowClear.prototype.update = function (decorated, data) {
      decorated.call(this, data);
  
      if (this.$selection.find('.select2-selection__placeholder').length > 0 ||
          data.length === 0) {
        return;
      }
  
      var $remove = $(
        '<span class="select2-selection__clear">' +
          '&times;' +
        '</span>'
      );
      $remove.data('data', data);
  
      this.$selection.find('.select2-selection__rendered').prepend($remove);
    };
  
    return AllowClear;
  });
  
  S2.define('select2/selection/search',[
    'jquery',
    '../utils',
    '../keys'
  ], function ($, Utils, KEYS) {
    function Search (decorated, $element, options) {
      decorated.call(this, $element, options);
    }
  
    Search.prototype.render = function (decorated) {
      var $search = $(
        '<li class="select2-search select2-search--inline">' +
          '<input class="select2-search__field" type="search" tabindex="-1"' +
          ' autocomplete="off" autocorrect="off" autocapitalize="off"' +
          ' spellcheck="false" role="textbox" />' +
        '</li>'
      );
  
      this.$searchContainer = $search;
      this.$search = $search.find('input');
  
      var $rendered = decorated.call(this);
  
      return $rendered;
    };
  
    Search.prototype.bind = function (decorated, container, $container) {
      var self = this;
  
      decorated.call(this, container, $container);
  
      container.on('open', function () {
        self.$search.attr('tabindex', 0);
  
        self.$search.focus();
      });
  
      container.on('close', function () {
        self.$search.attr('tabindex', -1);
  
        self.$search.val('');
        self.$search.focus();
      });
  
      container.on('enable', function () {
        self.$search.prop('disabled', false);
      });
  
      container.on('disable', function () {
        self.$search.prop('disabled', true);
      });
  
      this.$selection.on('focusin', '.select2-search--inline', function (evt) {
        self.trigger('focus', evt);
      });
  
      this.$selection.on('focusout', '.select2-search--inline', function (evt) {
        self.trigger('blur', evt);
      });
  
      this.$selection.on('keydown', '.select2-search--inline', function (evt) {
        evt.stopPropagation();
  
        self.trigger('keypress', evt);
  
        self._keyUpPrevented = evt.isDefaultPrevented();
  
        var key = evt.which;
  
        if (key === KEYS.BACKSPACE && self.$search.val() === '') {
          var $previousChoice = self.$searchContainer
            .prev('.select2-selection__choice');
  
          if ($previousChoice.length > 0) {
            var item = $previousChoice.data('data');
  
            self.searchRemoveChoice(item);
  
            evt.preventDefault();
          }
        }
      });
  
      // Workaround for browsers which do not support the `input` event
      // This will prevent double-triggering of events for browsers which support
      // both the `keyup` and `input` events.
      this.$selection.on('input', '.select2-search--inline', function (evt) {
        // Unbind the duplicated `keyup` event
        self.$selection.off('keyup.search');
      });
  
      this.$selection.on('keyup.search input', '.select2-search--inline',
          function (evt) {
        self.handleSearch(evt);
      });
    };
  
    Search.prototype.createPlaceholder = function (decorated, placeholder) {
      this.$search.attr('placeholder', placeholder.text);
    };
  
    Search.prototype.update = function (decorated, data) {
      this.$search.attr('placeholder', '');
  
      decorated.call(this, data);
  
      this.$selection.find('.select2-selection__rendered')
                     .append(this.$searchContainer);
  
      this.resizeSearch();
    };
  
    Search.prototype.handleSearch = function () {
      this.resizeSearch();
  
      if (!this._keyUpPrevented) {
        var input = this.$search.val();
  
        this.trigger('query', {
          term: input
        });
      }
  
      this._keyUpPrevented = false;
    };
  
    Search.prototype.searchRemoveChoice = function (decorated, item) {
      this.trigger('unselect', {
        data: item
      });
  
      this.trigger('open');
  
      this.$search.val(item.text + ' ');
    };
  
    Search.prototype.resizeSearch = function () {
      this.$search.css('width', '25px');
  
      var width = '';
  
      if (this.$search.attr('placeholder') !== '') {
        width = this.$selection.find('.select2-selection__rendered').innerWidth();
      } else {
        var minimumWidth = this.$search.val().length + 1;
  
        width = (minimumWidth * 0.75) + 'em';
      }
  
      this.$search.css('width', width);
    };
  
    return Search;
  });
  
  S2.define('select2/selection/eventRelay',[
    'jquery'
  ], function ($) {
    function EventRelay () { }
  
    EventRelay.prototype.bind = function (decorated, container, $container) {
      var self = this;
      var relayEvents = [
        'open', 'opening',
        'close', 'closing',
        'select', 'selecting',
        'unselect', 'unselecting'
      ];
  
      var preventableEvents = ['opening', 'closing', 'selecting', 'unselecting'];
  
      decorated.call(this, container, $container);
  
      container.on('*', function (name, params) {
        // Ignore events that should not be relayed
        if ($.inArray(name, relayEvents) === -1) {
          return;
        }
  
        // The parameters should always be an object
        params = params || {};
  
        // Generate the jQuery event for the Select2 event
        var evt = $.Event('select2:' + name, {
          params: params
        });
  
        self.$element.trigger(evt);
  
        // Only handle preventable events if it was one
        if ($.inArray(name, preventableEvents) === -1) {
          return;
        }
  
        params.prevented = evt.isDefaultPrevented();
      });
    };
  
    return EventRelay;
  });
  
  S2.define('select2/translation',[
    'jquery',
    'require'
  ], function ($, require) {
    function Translation (dict) {
      this.dict = dict || {};
    }
  
    Translation.prototype.all = function () {
      return this.dict;
    };
  
    Translation.prototype.get = function (key) {
      return this.dict[key];
    };
  
    Translation.prototype.extend = function (translation) {
      this.dict = $.extend({}, translation.all(), this.dict);
    };
  
    // Static functions
  
    Translation._cache = {};
  
    Translation.loadPath = function (path) {
      if (!(path in Translation._cache)) {
        var translations = require(path);
  
        Translation._cache[path] = translations;
      }
  
      return new Translation(Translation._cache[path]);
    };
  
    return Translation;
  });
  
  S2.define('select2/diacritics',[
  
  ], function () {
    var diacritics = {
      '\u24B6': 'A',
      '\uFF21': 'A',
      '\u00C0': 'A',
      '\u00C1': 'A',
      '\u00C2': 'A',
      '\u1EA6': 'A',
      '\u1EA4': 'A',
      '\u1EAA': 'A',
      '\u1EA8': 'A',
      '\u00C3': 'A',
      '\u0100': 'A',
      '\u0102': 'A',
      '\u1EB0': 'A',
      '\u1EAE': 'A',
      '\u1EB4': 'A',
      '\u1EB2': 'A',
      '\u0226': 'A',
      '\u01E0': 'A',
      '\u00C4': 'A',
      '\u01DE': 'A',
      '\u1EA2': 'A',
      '\u00C5': 'A',
      '\u01FA': 'A',
      '\u01CD': 'A',
      '\u0200': 'A',
      '\u0202': 'A',
      '\u1EA0': 'A',
      '\u1EAC': 'A',
      '\u1EB6': 'A',
      '\u1E00': 'A',
      '\u0104': 'A',
      '\u023A': 'A',
      '\u2C6F': 'A',
      '\uA732': 'AA',
      '\u00C6': 'AE',
      '\u01FC': 'AE',
      '\u01E2': 'AE',
      '\uA734': 'AO',
      '\uA736': 'AU',
      '\uA738': 'AV',
      '\uA73A': 'AV',
      '\uA73C': 'AY',
      '\u24B7': 'B',
      '\uFF22': 'B',
      '\u1E02': 'B',
      '\u1E04': 'B',
      '\u1E06': 'B',
      '\u0243': 'B',
      '\u0182': 'B',
      '\u0181': 'B',
      '\u24B8': 'C',
      '\uFF23': 'C',
      '\u0106': 'C',
      '\u0108': 'C',
      '\u010A': 'C',
      '\u010C': 'C',
      '\u00C7': 'C',
      '\u1E08': 'C',
      '\u0187': 'C',
      '\u023B': 'C',
      '\uA73E': 'C',
      '\u24B9': 'D',
      '\uFF24': 'D',
      '\u1E0A': 'D',
      '\u010E': 'D',
      '\u1E0C': 'D',
      '\u1E10': 'D',
      '\u1E12': 'D',
      '\u1E0E': 'D',
      '\u0110': 'D',
      '\u018B': 'D',
      '\u018A': 'D',
      '\u0189': 'D',
      '\uA779': 'D',
      '\u01F1': 'DZ',
      '\u01C4': 'DZ',
      '\u01F2': 'Dz',
      '\u01C5': 'Dz',
      '\u24BA': 'E',
      '\uFF25': 'E',
      '\u00C8': 'E',
      '\u00C9': 'E',
      '\u00CA': 'E',
      '\u1EC0': 'E',
      '\u1EBE': 'E',
      '\u1EC4': 'E',
      '\u1EC2': 'E',
      '\u1EBC': 'E',
      '\u0112': 'E',
      '\u1E14': 'E',
      '\u1E16': 'E',
      '\u0114': 'E',
      '\u0116': 'E',
      '\u00CB': 'E',
      '\u1EBA': 'E',
      '\u011A': 'E',
      '\u0204': 'E',
      '\u0206': 'E',
      '\u1EB8': 'E',
      '\u1EC6': 'E',
      '\u0228': 'E',
      '\u1E1C': 'E',
      '\u0118': 'E',
      '\u1E18': 'E',
      '\u1E1A': 'E',
      '\u0190': 'E',
      '\u018E': 'E',
      '\u24BB': 'F',
      '\uFF26': 'F',
      '\u1E1E': 'F',
      '\u0191': 'F',
      '\uA77B': 'F',
      '\u24BC': 'G',
      '\uFF27': 'G',
      '\u01F4': 'G',
      '\u011C': 'G',
      '\u1E20': 'G',
      '\u011E': 'G',
      '\u0120': 'G',
      '\u01E6': 'G',
      '\u0122': 'G',
      '\u01E4': 'G',
      '\u0193': 'G',
      '\uA7A0': 'G',
      '\uA77D': 'G',
      '\uA77E': 'G',
      '\u24BD': 'H',
      '\uFF28': 'H',
      '\u0124': 'H',
      '\u1E22': 'H',
      '\u1E26': 'H',
      '\u021E': 'H',
      '\u1E24': 'H',
      '\u1E28': 'H',
      '\u1E2A': 'H',
      '\u0126': 'H',
      '\u2C67': 'H',
      '\u2C75': 'H',
      '\uA78D': 'H',
      '\u24BE': 'I',
      '\uFF29': 'I',
      '\u00CC': 'I',
      '\u00CD': 'I',
      '\u00CE': 'I',
      '\u0128': 'I',
      '\u012A': 'I',
      '\u012C': 'I',
      '\u0130': 'I',
      '\u00CF': 'I',
      '\u1E2E': 'I',
      '\u1EC8': 'I',
      '\u01CF': 'I',
      '\u0208': 'I',
      '\u020A': 'I',
      '\u1ECA': 'I',
      '\u012E': 'I',
      '\u1E2C': 'I',
      '\u0197': 'I',
      '\u24BF': 'J',
      '\uFF2A': 'J',
      '\u0134': 'J',
      '\u0248': 'J',
      '\u24C0': 'K',
      '\uFF2B': 'K',
      '\u1E30': 'K',
      '\u01E8': 'K',
      '\u1E32': 'K',
      '\u0136': 'K',
      '\u1E34': 'K',
      '\u0198': 'K',
      '\u2C69': 'K',
      '\uA740': 'K',
      '\uA742': 'K',
      '\uA744': 'K',
      '\uA7A2': 'K',
      '\u24C1': 'L',
      '\uFF2C': 'L',
      '\u013F': 'L',
      '\u0139': 'L',
      '\u013D': 'L',
      '\u1E36': 'L',
      '\u1E38': 'L',
      '\u013B': 'L',
      '\u1E3C': 'L',
      '\u1E3A': 'L',
      '\u0141': 'L',
      '\u023D': 'L',
      '\u2C62': 'L',
      '\u2C60': 'L',
      '\uA748': 'L',
      '\uA746': 'L',
      '\uA780': 'L',
      '\u01C7': 'LJ',
      '\u01C8': 'Lj',
      '\u24C2': 'M',
      '\uFF2D': 'M',
      '\u1E3E': 'M',
      '\u1E40': 'M',
      '\u1E42': 'M',
      '\u2C6E': 'M',
      '\u019C': 'M',
      '\u24C3': 'N',
      '\uFF2E': 'N',
      '\u01F8': 'N',
      '\u0143': 'N',
      '\u00D1': 'N',
      '\u1E44': 'N',
      '\u0147': 'N',
      '\u1E46': 'N',
      '\u0145': 'N',
      '\u1E4A': 'N',
      '\u1E48': 'N',
      '\u0220': 'N',
      '\u019D': 'N',
      '\uA790': 'N',
      '\uA7A4': 'N',
      '\u01CA': 'NJ',
      '\u01CB': 'Nj',
      '\u24C4': 'O',
      '\uFF2F': 'O',
      '\u00D2': 'O',
      '\u00D3': 'O',
      '\u00D4': 'O',
      '\u1ED2': 'O',
      '\u1ED0': 'O',
      '\u1ED6': 'O',
      '\u1ED4': 'O',
      '\u00D5': 'O',
      '\u1E4C': 'O',
      '\u022C': 'O',
      '\u1E4E': 'O',
      '\u014C': 'O',
      '\u1E50': 'O',
      '\u1E52': 'O',
      '\u014E': 'O',
      '\u022E': 'O',
      '\u0230': 'O',
      '\u00D6': 'O',
      '\u022A': 'O',
      '\u1ECE': 'O',
      '\u0150': 'O',
      '\u01D1': 'O',
      '\u020C': 'O',
      '\u020E': 'O',
      '\u01A0': 'O',
      '\u1EDC': 'O',
      '\u1EDA': 'O',
      '\u1EE0': 'O',
      '\u1EDE': 'O',
      '\u1EE2': 'O',
      '\u1ECC': 'O',
      '\u1ED8': 'O',
      '\u01EA': 'O',
      '\u01EC': 'O',
      '\u00D8': 'O',
      '\u01FE': 'O',
      '\u0186': 'O',
      '\u019F': 'O',
      '\uA74A': 'O',
      '\uA74C': 'O',
      '\u01A2': 'OI',
      '\uA74E': 'OO',
      '\u0222': 'OU',
      '\u24C5': 'P',
      '\uFF30': 'P',
      '\u1E54': 'P',
      '\u1E56': 'P',
      '\u01A4': 'P',
      '\u2C63': 'P',
      '\uA750': 'P',
      '\uA752': 'P',
      '\uA754': 'P',
      '\u24C6': 'Q',
      '\uFF31': 'Q',
      '\uA756': 'Q',
      '\uA758': 'Q',
      '\u024A': 'Q',
      '\u24C7': 'R',
      '\uFF32': 'R',
      '\u0154': 'R',
      '\u1E58': 'R',
      '\u0158': 'R',
      '\u0210': 'R',
      '\u0212': 'R',
      '\u1E5A': 'R',
      '\u1E5C': 'R',
      '\u0156': 'R',
      '\u1E5E': 'R',
      '\u024C': 'R',
      '\u2C64': 'R',
      '\uA75A': 'R',
      '\uA7A6': 'R',
      '\uA782': 'R',
      '\u24C8': 'S',
      '\uFF33': 'S',
      '\u1E9E': 'S',
      '\u015A': 'S',
      '\u1E64': 'S',
      '\u015C': 'S',
      '\u1E60': 'S',
      '\u0160': 'S',
      '\u1E66': 'S',
      '\u1E62': 'S',
      '\u1E68': 'S',
      '\u0218': 'S',
      '\u015E': 'S',
      '\u2C7E': 'S',
      '\uA7A8': 'S',
      '\uA784': 'S',
      '\u24C9': 'T',
      '\uFF34': 'T',
      '\u1E6A': 'T',
      '\u0164': 'T',
      '\u1E6C': 'T',
      '\u021A': 'T',
      '\u0162': 'T',
      '\u1E70': 'T',
      '\u1E6E': 'T',
      '\u0166': 'T',
      '\u01AC': 'T',
      '\u01AE': 'T',
      '\u023E': 'T',
      '\uA786': 'T',
      '\uA728': 'TZ',
      '\u24CA': 'U',
      '\uFF35': 'U',
      '\u00D9': 'U',
      '\u00DA': 'U',
      '\u00DB': 'U',
      '\u0168': 'U',
      '\u1E78': 'U',
      '\u016A': 'U',
      '\u1E7A': 'U',
      '\u016C': 'U',
      '\u00DC': 'U',
      '\u01DB': 'U',
      '\u01D7': 'U',
      '\u01D5': 'U',
      '\u01D9': 'U',
      '\u1EE6': 'U',
      '\u016E': 'U',
      '\u0170': 'U',
      '\u01D3': 'U',
      '\u0214': 'U',
      '\u0216': 'U',
      '\u01AF': 'U',
      '\u1EEA': 'U',
      '\u1EE8': 'U',
      '\u1EEE': 'U',
      '\u1EEC': 'U',
      '\u1EF0': 'U',
      '\u1EE4': 'U',
      '\u1E72': 'U',
      '\u0172': 'U',
      '\u1E76': 'U',
      '\u1E74': 'U',
      '\u0244': 'U',
      '\u24CB': 'V',
      '\uFF36': 'V',
      '\u1E7C': 'V',
      '\u1E7E': 'V',
      '\u01B2': 'V',
      '\uA75E': 'V',
      '\u0245': 'V',
      '\uA760': 'VY',
      '\u24CC': 'W',
      '\uFF37': 'W',
      '\u1E80': 'W',
      '\u1E82': 'W',
      '\u0174': 'W',
      '\u1E86': 'W',
      '\u1E84': 'W',
      '\u1E88': 'W',
      '\u2C72': 'W',
      '\u24CD': 'X',
      '\uFF38': 'X',
      '\u1E8A': 'X',
      '\u1E8C': 'X',
      '\u24CE': 'Y',
      '\uFF39': 'Y',
      '\u1EF2': 'Y',
      '\u00DD': 'Y',
      '\u0176': 'Y',
      '\u1EF8': 'Y',
      '\u0232': 'Y',
      '\u1E8E': 'Y',
      '\u0178': 'Y',
      '\u1EF6': 'Y',
      '\u1EF4': 'Y',
      '\u01B3': 'Y',
      '\u024E': 'Y',
      '\u1EFE': 'Y',
      '\u24CF': 'Z',
      '\uFF3A': 'Z',
      '\u0179': 'Z',
      '\u1E90': 'Z',
      '\u017B': 'Z',
      '\u017D': 'Z',
      '\u1E92': 'Z',
      '\u1E94': 'Z',
      '\u01B5': 'Z',
      '\u0224': 'Z',
      '\u2C7F': 'Z',
      '\u2C6B': 'Z',
      '\uA762': 'Z',
      '\u24D0': 'a',
      '\uFF41': 'a',
      '\u1E9A': 'a',
      '\u00E0': 'a',
      '\u00E1': 'a',
      '\u00E2': 'a',
      '\u1EA7': 'a',
      '\u1EA5': 'a',
      '\u1EAB': 'a',
      '\u1EA9': 'a',
      '\u00E3': 'a',
      '\u0101': 'a',
      '\u0103': 'a',
      '\u1EB1': 'a',
      '\u1EAF': 'a',
      '\u1EB5': 'a',
      '\u1EB3': 'a',
      '\u0227': 'a',
      '\u01E1': 'a',
      '\u00E4': 'a',
      '\u01DF': 'a',
      '\u1EA3': 'a',
      '\u00E5': 'a',
      '\u01FB': 'a',
      '\u01CE': 'a',
      '\u0201': 'a',
      '\u0203': 'a',
      '\u1EA1': 'a',
      '\u1EAD': 'a',
      '\u1EB7': 'a',
      '\u1E01': 'a',
      '\u0105': 'a',
      '\u2C65': 'a',
      '\u0250': 'a',
      '\uA733': 'aa',
      '\u00E6': 'ae',
      '\u01FD': 'ae',
      '\u01E3': 'ae',
      '\uA735': 'ao',
      '\uA737': 'au',
      '\uA739': 'av',
      '\uA73B': 'av',
      '\uA73D': 'ay',
      '\u24D1': 'b',
      '\uFF42': 'b',
      '\u1E03': 'b',
      '\u1E05': 'b',
      '\u1E07': 'b',
      '\u0180': 'b',
      '\u0183': 'b',
      '\u0253': 'b',
      '\u24D2': 'c',
      '\uFF43': 'c',
      '\u0107': 'c',
      '\u0109': 'c',
      '\u010B': 'c',
      '\u010D': 'c',
      '\u00E7': 'c',
      '\u1E09': 'c',
      '\u0188': 'c',
      '\u023C': 'c',
      '\uA73F': 'c',
      '\u2184': 'c',
      '\u24D3': 'd',
      '\uFF44': 'd',
      '\u1E0B': 'd',
      '\u010F': 'd',
      '\u1E0D': 'd',
      '\u1E11': 'd',
      '\u1E13': 'd',
      '\u1E0F': 'd',
      '\u0111': 'd',
      '\u018C': 'd',
      '\u0256': 'd',
      '\u0257': 'd',
      '\uA77A': 'd',
      '\u01F3': 'dz',
      '\u01C6': 'dz',
      '\u24D4': 'e',
      '\uFF45': 'e',
      '\u00E8': 'e',
      '\u00E9': 'e',
      '\u00EA': 'e',
      '\u1EC1': 'e',
      '\u1EBF': 'e',
      '\u1EC5': 'e',
      '\u1EC3': 'e',
      '\u1EBD': 'e',
      '\u0113': 'e',
      '\u1E15': 'e',
      '\u1E17': 'e',
      '\u0115': 'e',
      '\u0117': 'e',
      '\u00EB': 'e',
      '\u1EBB': 'e',
      '\u011B': 'e',
      '\u0205': 'e',
      '\u0207': 'e',
      '\u1EB9': 'e',
      '\u1EC7': 'e',
      '\u0229': 'e',
      '\u1E1D': 'e',
      '\u0119': 'e',
      '\u1E19': 'e',
      '\u1E1B': 'e',
      '\u0247': 'e',
      '\u025B': 'e',
      '\u01DD': 'e',
      '\u24D5': 'f',
      '\uFF46': 'f',
      '\u1E1F': 'f',
      '\u0192': 'f',
      '\uA77C': 'f',
      '\u24D6': 'g',
      '\uFF47': 'g',
      '\u01F5': 'g',
      '\u011D': 'g',
      '\u1E21': 'g',
      '\u011F': 'g',
      '\u0121': 'g',
      '\u01E7': 'g',
      '\u0123': 'g',
      '\u01E5': 'g',
      '\u0260': 'g',
      '\uA7A1': 'g',
      '\u1D79': 'g',
      '\uA77F': 'g',
      '\u24D7': 'h',
      '\uFF48': 'h',
      '\u0125': 'h',
      '\u1E23': 'h',
      '\u1E27': 'h',
      '\u021F': 'h',
      '\u1E25': 'h',
      '\u1E29': 'h',
      '\u1E2B': 'h',
      '\u1E96': 'h',
      '\u0127': 'h',
      '\u2C68': 'h',
      '\u2C76': 'h',
      '\u0265': 'h',
      '\u0195': 'hv',
      '\u24D8': 'i',
      '\uFF49': 'i',
      '\u00EC': 'i',
      '\u00ED': 'i',
      '\u00EE': 'i',
      '\u0129': 'i',
      '\u012B': 'i',
      '\u012D': 'i',
      '\u00EF': 'i',
      '\u1E2F': 'i',
      '\u1EC9': 'i',
      '\u01D0': 'i',
      '\u0209': 'i',
      '\u020B': 'i',
      '\u1ECB': 'i',
      '\u012F': 'i',
      '\u1E2D': 'i',
      '\u0268': 'i',
      '\u0131': 'i',
      '\u24D9': 'j',
      '\uFF4A': 'j',
      '\u0135': 'j',
      '\u01F0': 'j',
      '\u0249': 'j',
      '\u24DA': 'k',
      '\uFF4B': 'k',
      '\u1E31': 'k',
      '\u01E9': 'k',
      '\u1E33': 'k',
      '\u0137': 'k',
      '\u1E35': 'k',
      '\u0199': 'k',
      '\u2C6A': 'k',
      '\uA741': 'k',
      '\uA743': 'k',
      '\uA745': 'k',
      '\uA7A3': 'k',
      '\u24DB': 'l',
      '\uFF4C': 'l',
      '\u0140': 'l',
      '\u013A': 'l',
      '\u013E': 'l',
      '\u1E37': 'l',
      '\u1E39': 'l',
      '\u013C': 'l',
      '\u1E3D': 'l',
      '\u1E3B': 'l',
      '\u017F': 'l',
      '\u0142': 'l',
      '\u019A': 'l',
      '\u026B': 'l',
      '\u2C61': 'l',
      '\uA749': 'l',
      '\uA781': 'l',
      '\uA747': 'l',
      '\u01C9': 'lj',
      '\u24DC': 'm',
      '\uFF4D': 'm',
      '\u1E3F': 'm',
      '\u1E41': 'm',
      '\u1E43': 'm',
      '\u0271': 'm',
      '\u026F': 'm',
      '\u24DD': 'n',
      '\uFF4E': 'n',
      '\u01F9': 'n',
      '\u0144': 'n',
      '\u00F1': 'n',
      '\u1E45': 'n',
      '\u0148': 'n',
      '\u1E47': 'n',
      '\u0146': 'n',
      '\u1E4B': 'n',
      '\u1E49': 'n',
      '\u019E': 'n',
      '\u0272': 'n',
      '\u0149': 'n',
      '\uA791': 'n',
      '\uA7A5': 'n',
      '\u01CC': 'nj',
      '\u24DE': 'o',
      '\uFF4F': 'o',
      '\u00F2': 'o',
      '\u00F3': 'o',
      '\u00F4': 'o',
      '\u1ED3': 'o',
      '\u1ED1': 'o',
      '\u1ED7': 'o',
      '\u1ED5': 'o',
      '\u00F5': 'o',
      '\u1E4D': 'o',
      '\u022D': 'o',
      '\u1E4F': 'o',
      '\u014D': 'o',
      '\u1E51': 'o',
      '\u1E53': 'o',
      '\u014F': 'o',
      '\u022F': 'o',
      '\u0231': 'o',
      '\u00F6': 'o',
      '\u022B': 'o',
      '\u1ECF': 'o',
      '\u0151': 'o',
      '\u01D2': 'o',
      '\u020D': 'o',
      '\u020F': 'o',
      '\u01A1': 'o',
      '\u1EDD': 'o',
      '\u1EDB': 'o',
      '\u1EE1': 'o',
      '\u1EDF': 'o',
      '\u1EE3': 'o',
      '\u1ECD': 'o',
      '\u1ED9': 'o',
      '\u01EB': 'o',
      '\u01ED': 'o',
      '\u00F8': 'o',
      '\u01FF': 'o',
      '\u0254': 'o',
      '\uA74B': 'o',
      '\uA74D': 'o',
      '\u0275': 'o',
      '\u01A3': 'oi',
      '\u0223': 'ou',
      '\uA74F': 'oo',
      '\u24DF': 'p',
      '\uFF50': 'p',
      '\u1E55': 'p',
      '\u1E57': 'p',
      '\u01A5': 'p',
      '\u1D7D': 'p',
      '\uA751': 'p',
      '\uA753': 'p',
      '\uA755': 'p',
      '\u24E0': 'q',
      '\uFF51': 'q',
      '\u024B': 'q',
      '\uA757': 'q',
      '\uA759': 'q',
      '\u24E1': 'r',
      '\uFF52': 'r',
      '\u0155': 'r',
      '\u1E59': 'r',
      '\u0159': 'r',
      '\u0211': 'r',
      '\u0213': 'r',
      '\u1E5B': 'r',
      '\u1E5D': 'r',
      '\u0157': 'r',
      '\u1E5F': 'r',
      '\u024D': 'r',
      '\u027D': 'r',
      '\uA75B': 'r',
      '\uA7A7': 'r',
      '\uA783': 'r',
      '\u24E2': 's',
      '\uFF53': 's',
      '\u00DF': 's',
      '\u015B': 's',
      '\u1E65': 's',
      '\u015D': 's',
      '\u1E61': 's',
      '\u0161': 's',
      '\u1E67': 's',
      '\u1E63': 's',
      '\u1E69': 's',
      '\u0219': 's',
      '\u015F': 's',
      '\u023F': 's',
      '\uA7A9': 's',
      '\uA785': 's',
      '\u1E9B': 's',
      '\u24E3': 't',
      '\uFF54': 't',
      '\u1E6B': 't',
      '\u1E97': 't',
      '\u0165': 't',
      '\u1E6D': 't',
      '\u021B': 't',
      '\u0163': 't',
      '\u1E71': 't',
      '\u1E6F': 't',
      '\u0167': 't',
      '\u01AD': 't',
      '\u0288': 't',
      '\u2C66': 't',
      '\uA787': 't',
      '\uA729': 'tz',
      '\u24E4': 'u',
      '\uFF55': 'u',
      '\u00F9': 'u',
      '\u00FA': 'u',
      '\u00FB': 'u',
      '\u0169': 'u',
      '\u1E79': 'u',
      '\u016B': 'u',
      '\u1E7B': 'u',
      '\u016D': 'u',
      '\u00FC': 'u',
      '\u01DC': 'u',
      '\u01D8': 'u',
      '\u01D6': 'u',
      '\u01DA': 'u',
      '\u1EE7': 'u',
      '\u016F': 'u',
      '\u0171': 'u',
      '\u01D4': 'u',
      '\u0215': 'u',
      '\u0217': 'u',
      '\u01B0': 'u',
      '\u1EEB': 'u',
      '\u1EE9': 'u',
      '\u1EEF': 'u',
      '\u1EED': 'u',
      '\u1EF1': 'u',
      '\u1EE5': 'u',
      '\u1E73': 'u',
      '\u0173': 'u',
      '\u1E77': 'u',
      '\u1E75': 'u',
      '\u0289': 'u',
      '\u24E5': 'v',
      '\uFF56': 'v',
      '\u1E7D': 'v',
      '\u1E7F': 'v',
      '\u028B': 'v',
      '\uA75F': 'v',
      '\u028C': 'v',
      '\uA761': 'vy',
      '\u24E6': 'w',
      '\uFF57': 'w',
      '\u1E81': 'w',
      '\u1E83': 'w',
      '\u0175': 'w',
      '\u1E87': 'w',
      '\u1E85': 'w',
      '\u1E98': 'w',
      '\u1E89': 'w',
      '\u2C73': 'w',
      '\u24E7': 'x',
      '\uFF58': 'x',
      '\u1E8B': 'x',
      '\u1E8D': 'x',
      '\u24E8': 'y',
      '\uFF59': 'y',
      '\u1EF3': 'y',
      '\u00FD': 'y',
      '\u0177': 'y',
      '\u1EF9': 'y',
      '\u0233': 'y',
      '\u1E8F': 'y',
      '\u00FF': 'y',
      '\u1EF7': 'y',
      '\u1E99': 'y',
      '\u1EF5': 'y',
      '\u01B4': 'y',
      '\u024F': 'y',
      '\u1EFF': 'y',
      '\u24E9': 'z',
      '\uFF5A': 'z',
      '\u017A': 'z',
      '\u1E91': 'z',
      '\u017C': 'z',
      '\u017E': 'z',
      '\u1E93': 'z',
      '\u1E95': 'z',
      '\u01B6': 'z',
      '\u0225': 'z',
      '\u0240': 'z',
      '\u2C6C': 'z',
      '\uA763': 'z',
      '\u0386': '\u0391',
      '\u0388': '\u0395',
      '\u0389': '\u0397',
      '\u038A': '\u0399',
      '\u03AA': '\u0399',
      '\u038C': '\u039F',
      '\u038E': '\u03A5',
      '\u03AB': '\u03A5',
      '\u038F': '\u03A9',
      '\u03AC': '\u03B1',
      '\u03AD': '\u03B5',
      '\u03AE': '\u03B7',
      '\u03AF': '\u03B9',
      '\u03CA': '\u03B9',
      '\u0390': '\u03B9',
      '\u03CC': '\u03BF',
      '\u03CD': '\u03C5',
      '\u03CB': '\u03C5',
      '\u03B0': '\u03C5',
      '\u03C9': '\u03C9',
      '\u03C2': '\u03C3'
    };
  
    return diacritics;
  });
  
  S2.define('select2/data/base',[
    '../utils'
  ], function (Utils) {
    function BaseAdapter ($element, options) {
      BaseAdapter.__super__.constructor.call(this);
    }
  
    Utils.Extend(BaseAdapter, Utils.Observable);
  
    BaseAdapter.prototype.current = function (callback) {
      throw new Error('The `current` method must be defined in child classes.');
    };
  
    BaseAdapter.prototype.query = function (params, callback) {
      throw new Error('The `query` method must be defined in child classes.');
    };
  
    BaseAdapter.prototype.bind = function (container, $container) {
      // Can be implemented in subclasses
    };
  
    BaseAdapter.prototype.destroy = function () {
      // Can be implemented in subclasses
    };
  
    BaseAdapter.prototype.generateResultId = function (container, data) {
      var id = container.id + '-result-';
  
      id += Utils.generateChars(4);
  
      if (data.id != null) {
        id += '-' + data.id.toString();
      } else {
        id += '-' + Utils.generateChars(4);
      }
      return id;
    };
  
    return BaseAdapter;
  });
  
  S2.define('select2/data/select',[
    './base',
    '../utils',
    'jquery'
  ], function (BaseAdapter, Utils, $) {
    function SelectAdapter ($element, options) {
      this.$element = $element;
      this.options = options;
  
      SelectAdapter.__super__.constructor.call(this);
    }
  
    Utils.Extend(SelectAdapter, BaseAdapter);
  
    SelectAdapter.prototype.current = function (callback) {
      var data = [];
      var self = this;
  
      this.$element.find(':selected').each(function () {
        var $option = $(this);
  
        var option = self.item($option);
  
        data.push(option);
      });
  
      callback(data);
    };
  
    SelectAdapter.prototype.select = function (data) {
      var self = this;
  
      data.selected = true;
  
      // If data.element is a DOM node, use it instead
      if ($(data.element).is('option')) {
        data.element.selected = true;
  
        this.$element.trigger('change');
  
        return;
      }
  
      if (this.$element.prop('multiple')) {
        this.current(function (currentData) {
          var val = [];
  
          data = [data];
          data.push.apply(data, currentData);
  
          for (var d = 0; d < data.length; d++) {
            var id = data[d].id;
  
            if ($.inArray(id, val) === -1) {
              val.push(id);
            }
          }
  
          self.$element.val(val);
          self.$element.trigger('change');
        });
      } else {
        var val = data.id;
  
        this.$element.val(val);
        this.$element.trigger('change');
      }
    };
  
    SelectAdapter.prototype.unselect = function (data) {
      var self = this;
  
      if (!this.$element.prop('multiple')) {
        return;
      }
  
      data.selected = false;
  
      if ($(data.element).is('option')) {
        data.element.selected = false;
  
        this.$element.trigger('change');
  
        return;
      }
  
      this.current(function (currentData) {
        var val = [];
  
        for (var d = 0; d < currentData.length; d++) {
          var id = currentData[d].id;
  
          if (id !== data.id && $.inArray(id, val) === -1) {
            val.push(id);
          }
        }
  
        self.$element.val(val);
  
        self.$element.trigger('change');
      });
    };
  
    SelectAdapter.prototype.bind = function (container, $container) {
      var self = this;
  
      this.container = container;
  
      container.on('select', function (params) {
        self.select(params.data);
      });
  
      container.on('unselect', function (params) {
        self.unselect(params.data);
      });
    };
  
    SelectAdapter.prototype.destroy = function () {
      // Remove anything added to child elements
      this.$element.find('*').each(function () {
        // Remove any custom data set by Select2
        $.removeData(this, 'data');
      });
    };
  
    SelectAdapter.prototype.query = function (params, callback) {
      var data = [];
      var self = this;
  
      var $options = this.$element.children();
  
      $options.each(function () {
        var $option = $(this);
  
        if (!$option.is('option') && !$option.is('optgroup')) {
          return;
        }
  
        var option = self.item($option);
  
        var matches = self.matches(params, option);
  
        if (matches !== null) {
          data.push(matches);
        }
      });
  
      callback({
        results: data
      });
    };
  
    SelectAdapter.prototype.addOptions = function ($options) {
      Utils.appendMany(this.$element, $options);
    };
  
    SelectAdapter.prototype.option = function (data) {
      var option;
  
      if (data.children) {
        option = document.createElement('optgroup');
        option.label = data.text;
      } else {
        option = document.createElement('option');
  
        if (option.textContent !== undefined) {
          option.textContent = data.text;
        } else {
          option.innerText = data.text;
        }
      }
  
      if (data.id) {
        option.value = data.id;
      }
  
      if (data.disabled) {
        option.disabled = true;
      }
  
      if (data.selected) {
        option.selected = true;
      }
  
      if (data.title) {
        option.title = data.title;
      }
  
      var $option = $(option);
  
      var normalizedData = this._normalizeItem(data);
      normalizedData.element = option;
  
      // Override the option's data with the combined data
      $.data(option, 'data', normalizedData);
  
      return $option;
    };
  
    SelectAdapter.prototype.item = function ($option) {
      var data = {};
  
      data = $.data($option[0], 'data');
  
      if (data != null) {
        return data;
      }
  
      if ($option.is('option')) {
        data = {
          id: $option.val(),
          text: $option.text(),
          disabled: $option.prop('disabled'),
          selected: $option.prop('selected'),
          title: $option.prop('title')
        };
      } else if ($option.is('optgroup')) {
        data = {
          text: $option.prop('label'),
          children: [],
          title: $option.prop('title')
        };
  
        var $children = $option.children('option');
        var children = [];
  
        for (var c = 0; c < $children.length; c++) {
          var $child = $($children[c]);
  
          var child = this.item($child);
  
          children.push(child);
        }
  
        data.children = children;
      }
  
      data = this._normalizeItem(data);
      data.element = $option[0];
  
      $.data($option[0], 'data', data);
  
      return data;
    };
  
    SelectAdapter.prototype._normalizeItem = function (item) {
      if (!$.isPlainObject(item)) {
        item = {
          id: item,
          text: item
        };
      }
  
      item = $.extend({}, {
        text: ''
      }, item);
  
      var defaults = {
        selected: false,
        disabled: false
      };
  
      if (item.id != null) {
        item.id = item.id.toString();
      }
  
      if (item.text != null) {
        item.text = item.text.toString();
      }
  
      if (item._resultId == null && item.id && this.container != null) {
        item._resultId = this.generateResultId(this.container, item);
      }
  
      return $.extend({}, defaults, item);
    };
  
    SelectAdapter.prototype.matches = function (params, data) {
      var matcher = this.options.get('matcher');
  
      return matcher(params, data);
    };
  
    return SelectAdapter;
  });
  
  S2.define('select2/data/array',[
    './select',
    '../utils',
    'jquery'
  ], function (SelectAdapter, Utils, $) {
    function ArrayAdapter ($element, options) {
      var data = options.get('data') || [];
  
      ArrayAdapter.__super__.constructor.call(this, $element, options);
  
      this.addOptions(this.convertToOptions(data));
    }
  
    Utils.Extend(ArrayAdapter, SelectAdapter);
  
    ArrayAdapter.prototype.select = function (data) {
      var $option = this.$element.find('option').filter(function (i, elm) {
        return elm.value == data.id.toString();
      });
  
      if ($option.length === 0) {
        $option = this.option(data);
  
        this.addOptions($option);
      }
  
      ArrayAdapter.__super__.select.call(this, data);
    };
  
    ArrayAdapter.prototype.convertToOptions = function (data) {
      var self = this;
  
      var $existing = this.$element.find('option');
      var existingIds = $existing.map(function () {
        return self.item($(this)).id;
      }).get();
  
      var $options = [];
  
      // Filter out all items except for the one passed in the argument
      function onlyItem (item) {
        return function () {
          return $(this).val() == item.id;
        };
      }
  
      for (var d = 0; d < data.length; d++) {
        var item = this._normalizeItem(data[d]);
  
        // Skip items which were pre-loaded, only merge the data
        if ($.inArray(item.id, existingIds) >= 0) {
          var $existingOption = $existing.filter(onlyItem(item));
  
          var existingData = this.item($existingOption);
          var newData = $.extend(true, {}, existingData, item);
  
          var $newOption = this.option(existingData);
  
          $existingOption.replaceWith($newOption);
  
          continue;
        }
  
        var $option = this.option(item);
  
        if (item.children) {
          var $children = this.convertToOptions(item.children);
  
          Utils.appendMany($option, $children);
        }
  
        $options.push($option);
      }
  
      return $options;
    };
  
    return ArrayAdapter;
  });
  
  S2.define('select2/data/ajax',[
    './array',
    '../utils',
    'jquery'
  ], function (ArrayAdapter, Utils, $) {
    function AjaxAdapter ($element, options) {
      this.ajaxOptions = this._applyDefaults(options.get('ajax'));
  
      if (this.ajaxOptions.processResults != null) {
        this.processResults = this.ajaxOptions.processResults;
      }
  
      ArrayAdapter.__super__.constructor.call(this, $element, options);
    }
  
    Utils.Extend(AjaxAdapter, ArrayAdapter);
  
    AjaxAdapter.prototype._applyDefaults = function (options) {
      var defaults = {
        data: function (params) {
          return {
            q: params.term
          };
        },
        transport: function (params, success, failure) {
          var $request = $.ajax(params);
  
          $request.then(success);
          $request.fail(failure);
  
          return $request;
        }
      };
  
      return $.extend({}, defaults, options, true);
    };
  
    AjaxAdapter.prototype.processResults = function (results) {
      return results;
    };
  
    AjaxAdapter.prototype.query = function (params, callback) {
      var matches = [];
      var self = this;
  
      if (this._request != null) {
        // JSONP requests cannot always be aborted
        if ($.isFunction(this._request.abort)) {
          this._request.abort();
        }
  
        this._request = null;
      }
  
      var options = $.extend({
        type: 'GET'
      }, this.ajaxOptions);
  
      if (typeof options.url === 'function') {
        options.url = options.url(params);
      }
  
      if (typeof options.data === 'function') {
        options.data = options.data(params);
      }
  
      function request () {
        var $request = options.transport(options, function (data) {
          var results = self.processResults(data, params);
  
          if (self.options.get('debug') && window.console && console.error) {
            // Check to make sure that the response included a `results` key.
            if (!results || !results.results || !$.isArray(results.results)) {
              console.error(
                'Select2: The AJAX results did not return an array in the ' +
                '`results` key of the response.'
              );
            }
          }
  
          callback(results);
        }, function () {
          // TODO: Handle AJAX errors
        });
  
        self._request = $request;
      }
  
      if (this.ajaxOptions.delay && params.term !== '') {
        if (this._queryTimeout) {
          window.clearTimeout(this._queryTimeout);
        }
  
        this._queryTimeout = window.setTimeout(request, this.ajaxOptions.delay);
      } else {
        request();
      }
    };
  
    return AjaxAdapter;
  });
  
  S2.define('select2/data/tags',[
    'jquery'
  ], function ($) {
    function Tags (decorated, $element, options) {
      var tags = options.get('tags');
  
      var createTag = options.get('createTag');
  
      if (createTag !== undefined) {
        this.createTag = createTag;
      }
  
      decorated.call(this, $element, options);
  
      if ($.isArray(tags)) {
        for (var t = 0; t < tags.length; t++) {
          var tag = tags[t];
          var item = this._normalizeItem(tag);
  
          var $option = this.option(item);
  
          this.$element.append($option);
        }
      }
    }
  
    Tags.prototype.query = function (decorated, params, callback) {
      var self = this;
  
      this._removeOldTags();
  
      if (params.term == null || params.page != null) {
        decorated.call(this, params, callback);
        return;
      }
  
      function wrapper (obj, child) {
        var data = obj.results;
  
        for (var i = 0; i < data.length; i++) {
          var option = data[i];
  
          var checkChildren = (
            option.children != null &&
            !wrapper({
              results: option.children
            }, true)
          );
  
          var checkText = option.text === params.term;
  
          if (checkText || checkChildren) {
            if (child) {
              return false;
            }
  
            obj.data = data;
            callback(obj);
  
            return;
          }
        }
  
        if (child) {
          return true;
        }
  
        var tag = self.createTag(params);
  
        if (tag != null) {
          var $option = self.option(tag);
          $option.attr('data-select2-tag', true);
  
          self.addOptions([$option]);
  
          self.insertTag(data, tag);
        }
  
        obj.results = data;
  
        callback(obj);
      }
  
      decorated.call(this, params, wrapper);
    };
  
    Tags.prototype.createTag = function (decorated, params) {
      var term = $.trim(params.term);
  
      if (term === '') {
        return null;
      }
  
      return {
        id: term,
        text: term
      };
    };
  
    Tags.prototype.insertTag = function (_, data, tag) {
      data.unshift(tag);
    };
  
    Tags.prototype._removeOldTags = function (_) {
      var tag = this._lastTag;
  
      var $options = this.$element.find('option[data-select2-tag]');
  
      $options.each(function () {
        if (this.selected) {
          return;
        }
  
        $(this).remove();
      });
    };
  
    return Tags;
  });
  
  S2.define('select2/data/tokenizer',[
    'jquery'
  ], function ($) {
    function Tokenizer (decorated, $element, options) {
      var tokenizer = options.get('tokenizer');
  
      if (tokenizer !== undefined) {
        this.tokenizer = tokenizer;
      }
  
      decorated.call(this, $element, options);
    }
  
    Tokenizer.prototype.bind = function (decorated, container, $container) {
      decorated.call(this, container, $container);
  
      this.$search =  container.dropdown.$search || container.selection.$search ||
        $container.find('.select2-search__field');
    };
  
    Tokenizer.prototype.query = function (decorated, params, callback) {
      var self = this;
  
      function select (data) {
        self.select(data);
      }
  
      params.term = params.term || '';
  
      var tokenData = this.tokenizer(params, this.options, select);
  
      if (tokenData.term !== params.term) {
        // Replace the search term if we have the search box
        if (this.$search.length) {
          this.$search.val(tokenData.term);
          this.$search.focus();
        }
  
        params.term = tokenData.term;
      }
  
      decorated.call(this, params, callback);
    };
  
    Tokenizer.prototype.tokenizer = function (_, params, options, callback) {
      var separators = options.get('tokenSeparators') || [];
      var term = params.term;
      var i = 0;
  
      var createTag = this.createTag || function (params) {
        return {
          id: params.term,
          text: params.term
        };
      };
  
      while (i < term.length) {
        var termChar = term[i];
  
        if ($.inArray(termChar, separators) === -1) {
          i++;
  
          continue;
        }
  
        var part = term.substr(0, i);
        var partParams = $.extend({}, params, {
          term: part
        });
  
        var data = createTag(partParams);
  
        callback(data);
  
        // Reset the term to not include the tokenized portion
        term = term.substr(i + 1) || '';
        i = 0;
      }
  
      return {
        term: term
      };
    };
  
    return Tokenizer;
  });
  
  S2.define('select2/data/minimumInputLength',[
  
  ], function () {
    function MinimumInputLength (decorated, $e, options) {
      this.minimumInputLength = options.get('minimumInputLength');
  
      decorated.call(this, $e, options);
    }
  
    MinimumInputLength.prototype.query = function (decorated, params, callback) {
      params.term = params.term || '';
  
      if (params.term.length < this.minimumInputLength) {
        this.trigger('results:message', {
          message: 'inputTooShort',
          args: {
            minimum: this.minimumInputLength,
            input: params.term,
            params: params
          }
        });
  
        return;
      }
  
      decorated.call(this, params, callback);
    };
  
    return MinimumInputLength;
  });
  
  S2.define('select2/data/maximumInputLength',[
  
  ], function () {
    function MaximumInputLength (decorated, $e, options) {
      this.maximumInputLength = options.get('maximumInputLength');
  
      decorated.call(this, $e, options);
    }
  
    MaximumInputLength.prototype.query = function (decorated, params, callback) {
      params.term = params.term || '';
  
      if (this.maximumInputLength > 0 &&
          params.term.length > this.maximumInputLength) {
        this.trigger('results:message', {
          message: 'inputTooLong',
          args: {
            maximum: this.maximumInputLength,
            input: params.term,
            params: params
          }
        });
  
        return;
      }
  
      decorated.call(this, params, callback);
    };
  
    return MaximumInputLength;
  });
  
  S2.define('select2/data/maximumSelectionLength',[
  
  ], function (){
    function MaximumSelectionLength (decorated, $e, options) {
      this.maximumSelectionLength = options.get('maximumSelectionLength');
  
      decorated.call(this, $e, options);
    }
  
    MaximumSelectionLength.prototype.query =
      function (decorated, params, callback) {
        var self = this;
  
        this.current(function (currentData) {
          var count = currentData != null ? currentData.length : 0;
          if (self.maximumSelectionLength > 0 &&
            count >= self.maximumSelectionLength) {
            self.trigger('results:message', {
              message: 'maximumSelected',
              args: {
                maximum: self.maximumSelectionLength
              }
            });
            return;
          }
          decorated.call(self, params, callback);
        });
    };
  
    return MaximumSelectionLength;
  });
  
  S2.define('select2/dropdown',[
    'jquery',
    './utils'
  ], function ($, Utils) {
    function Dropdown ($element, options) {
      this.$element = $element;
      this.options = options;
  
      Dropdown.__super__.constructor.call(this);
    }
  
    Utils.Extend(Dropdown, Utils.Observable);
  
    Dropdown.prototype.render = function () {
      var $dropdown = $(
        '<span class="select2-dropdown">' +
          '<span class="select2-results"></span>' +
        '</span>'
      );
  
      $dropdown.attr('dir', this.options.get('dir'));
  
      this.$dropdown = $dropdown;
  
      return $dropdown;
    };
  
    Dropdown.prototype.position = function ($dropdown, $container) {
      // Should be implmented in subclasses
    };
  
    Dropdown.prototype.destroy = function () {
      // Remove the dropdown from the DOM
      this.$dropdown.remove();
    };
  
    return Dropdown;
  });
  
  S2.define('select2/dropdown/search',[
    'jquery',
    '../utils'
  ], function ($, Utils) {
    function Search () { }
  
    Search.prototype.render = function (decorated) {
      var $rendered = decorated.call(this);
  
      var $search = $(
        '<span class="select2-search select2-search--dropdown">' +
          '<input class="select2-search__field" type="search" tabindex="-1"' +
          ' autocomplete="off" autocorrect="off" autocapitalize="off"' +
          ' spellcheck="false" role="textbox" />' +
        '</span>'
      );
  
      this.$searchContainer = $search;
      this.$search = $search.find('input');
  
      $rendered.prepend($search);
  
      return $rendered;
    };
  
    Search.prototype.bind = function (decorated, container, $container) {
      var self = this;
  
      decorated.call(this, container, $container);
  
      this.$search.on('keydown', function (evt) {
        self.trigger('keypress', evt);
  
        self._keyUpPrevented = evt.isDefaultPrevented();
      });
  
      // Workaround for browsers which do not support the `input` event
      // This will prevent double-triggering of events for browsers which support
      // both the `keyup` and `input` events.
      this.$search.on('input', function (evt) {
        // Unbind the duplicated `keyup` event
        $(this).off('keyup');
      });
  
      this.$search.on('keyup input', function (evt) {
        self.handleSearch(evt);
      });
  
      container.on('open', function () {
        self.$search.attr('tabindex', 0);
  
        self.$search.focus();
  
        window.setTimeout(function () {
          self.$search.focus();
        }, 0);
      });
  
      container.on('close', function () {
        self.$search.attr('tabindex', -1);
  
        self.$search.val('');
      });
  
      container.on('results:all', function (params) {
        if (params.query.term == null || params.query.term === '') {
          var showSearch = self.showSearch(params);
  
          if (showSearch) {
            self.$searchContainer.removeClass('select2-search--hide');
          } else {
            self.$searchContainer.addClass('select2-search--hide');
          }
        }
      });
    };
  
    Search.prototype.handleSearch = function (evt) {
      if (!this._keyUpPrevented) {
        var input = this.$search.val();
  
        this.trigger('query', {
          term: input
        });
      }
  
      this._keyUpPrevented = false;
    };
  
    Search.prototype.showSearch = function (_, params) {
      return true;
    };
  
    return Search;
  });
  
  S2.define('select2/dropdown/hidePlaceholder',[
  
  ], function () {
    function HidePlaceholder (decorated, $element, options, dataAdapter) {
      this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
  
      decorated.call(this, $element, options, dataAdapter);
    }
  
    HidePlaceholder.prototype.append = function (decorated, data) {
      data.results = this.removePlaceholder(data.results);
  
      decorated.call(this, data);
    };
  
    HidePlaceholder.prototype.normalizePlaceholder = function (_, placeholder) {
      if (typeof placeholder === 'string') {
        placeholder = {
          id: '',
          text: placeholder
        };
      }
  
      return placeholder;
    };
  
    HidePlaceholder.prototype.removePlaceholder = function (_, data) {
      var modifiedData = data.slice(0);
  
      for (var d = data.length - 1; d >= 0; d--) {
        var item = data[d];
  
        if (this.placeholder.id === item.id) {
          modifiedData.splice(d, 1);
        }
      }
  
      return modifiedData;
    };
  
    return HidePlaceholder;
  });
  
  S2.define('select2/dropdown/infiniteScroll',[
    'jquery'
  ], function ($) {
    function InfiniteScroll (decorated, $element, options, dataAdapter) {
      this.lastParams = {};
  
      decorated.call(this, $element, options, dataAdapter);
  
      this.$loadingMore = this.createLoadingMore();
      this.loading = false;
    }
  
    InfiniteScroll.prototype.append = function (decorated, data) {
      this.$loadingMore.remove();
      this.loading = false;
  
      decorated.call(this, data);
  
      if (this.showLoadingMore(data)) {
        this.$results.append(this.$loadingMore);
      }
    };
  
    InfiniteScroll.prototype.bind = function (decorated, container, $container) {
      var self = this;
  
      decorated.call(this, container, $container);
  
      container.on('query', function (params) {
        self.lastParams = params;
        self.loading = true;
      });
  
      container.on('query:append', function (params) {
        self.lastParams = params;
        self.loading = true;
      });
  
      this.$results.on('scroll', function () {
        var isLoadMoreVisible = $.contains(
          document.documentElement,
          self.$loadingMore[0]
        );
  
        if (self.loading || !isLoadMoreVisible) {
          return;
        }
  
        var currentOffset = self.$results.offset().top +
          self.$results.outerHeight(false);
        var loadingMoreOffset = self.$loadingMore.offset().top +
          self.$loadingMore.outerHeight(false);
  
        if (currentOffset + 50 >= loadingMoreOffset) {
          self.loadMore();
        }
      });
    };
  
    InfiniteScroll.prototype.loadMore = function () {
      this.loading = true;
  
      var params = $.extend({}, {page: 1}, this.lastParams);
  
      params.page++;
  
      this.trigger('query:append', params);
    };
  
    InfiniteScroll.prototype.showLoadingMore = function (_, data) {
      return data.pagination && data.pagination.more;
    };
  
    InfiniteScroll.prototype.createLoadingMore = function () {
      var $option = $(
        '<li class="option load-more" role="treeitem"></li>'
      );
  
      var message = this.options.get('translations').get('loadingMore');
  
      $option.html(message(this.lastParams));
  
      return $option;
    };
  
    return InfiniteScroll;
  });
  
  S2.define('select2/dropdown/attachBody',[
    'jquery',
    '../utils'
  ], function ($, Utils) {
    function AttachBody (decorated, $element, options) {
      this.$dropdownParent = options.get('dropdownParent') || document.body;
  
      decorated.call(this, $element, options);
    }
  
    AttachBody.prototype.bind = function (decorated, container, $container) {
      var self = this;
  
      var setupResultsEvents = false;
  
      decorated.call(this, container, $container);
  
      container.on('open', function () {
        self._showDropdown();
        self._attachPositioningHandler(container);
  
        if (!setupResultsEvents) {
          setupResultsEvents = true;
  
          container.on('results:all', function () {
            self._positionDropdown();
            self._resizeDropdown();
          });
  
          container.on('results:append', function () {
            self._positionDropdown();
            self._resizeDropdown();
          });
        }
      });
  
      container.on('close', function () {
        self._hideDropdown();
        self._detachPositioningHandler(container);
      });
  
      this.$dropdownContainer.on('mousedown', function (evt) {
        evt.stopPropagation();
      });
    };
  
    AttachBody.prototype.position = function (decorated, $dropdown, $container) {
      // Clone all of the container classes
      $dropdown.attr('class', $container.attr('class'));
  
      $dropdown.removeClass('select2');
      $dropdown.addClass('select2-container--open');
  
      $dropdown.css({
        position: 'absolute',
        top: -999999
      });
  
      this.$container = $container;
    };
  
    AttachBody.prototype.render = function (decorated) {
      var $container = $('<span></span>');
  
      var $dropdown = decorated.call(this);
      $container.append($dropdown);
  
      this.$dropdownContainer = $container;
  
      return $container;
    };
  
    AttachBody.prototype._hideDropdown = function (decorated) {
      this.$dropdownContainer.detach();
    };
  
    AttachBody.prototype._attachPositioningHandler = function (container) {
      var self = this;
  
      var scrollEvent = 'scroll.select2.' + container.id;
      var resizeEvent = 'resize.select2.' + container.id;
      var orientationEvent = 'orientationchange.select2.' + container.id;
  
      var $watchers = this.$container.parents().filter(Utils.hasScroll);
      $watchers.each(function () {
        $(this).data('select2-scroll-position', {
          x: $(this).scrollLeft(),
          y: $(this).scrollTop()
        });
      });
  
      $watchers.on(scrollEvent, function (ev) {
        var position = $(this).data('select2-scroll-position');
        $(this).scrollTop(position.y);
      });
  
      $(window).on(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent,
        function (e) {
        self._positionDropdown();
        self._resizeDropdown();
      });
    };
  
    AttachBody.prototype._detachPositioningHandler = function (container) {
      var scrollEvent = 'scroll.select2.' + container.id;
      var resizeEvent = 'resize.select2.' + container.id;
      var orientationEvent = 'orientationchange.select2.' + container.id;
  
      var $watchers = this.$container.parents().filter(Utils.hasScroll);
      $watchers.off(scrollEvent);
  
      $(window).off(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent);
    };
  
    AttachBody.prototype._positionDropdown = function () {
      var $window = $(window);
  
      var isCurrentlyAbove = this.$dropdown.hasClass('select2-dropdown--above');
      var isCurrentlyBelow = this.$dropdown.hasClass('select2-dropdown--below');
  
      var newDirection = null;
  
      var position = this.$container.position();
      var offset = this.$container.offset();
  
      offset.bottom = offset.top + this.$container.outerHeight(false);
  
      var container = {
        height: this.$container.outerHeight(false)
      };
  
      container.top = offset.top;
      container.bottom = offset.top + container.height;
  
      var dropdown = {
        height: this.$dropdown.outerHeight(false)
      };
  
      var viewport = {
        top: $window.scrollTop(),
        bottom: $window.scrollTop() + $window.height()
      };
  
      var enoughRoomAbove = viewport.top < (offset.top - dropdown.height);
      var enoughRoomBelow = viewport.bottom > (offset.bottom + dropdown.height);
  
      var css = {
        left: offset.left,
        top: container.bottom
      };
  
      if (!isCurrentlyAbove && !isCurrentlyBelow) {
        newDirection = 'below';
      }
  
      if (!enoughRoomBelow && enoughRoomAbove && !isCurrentlyAbove) {
        newDirection = 'above';
      } else if (!enoughRoomAbove && enoughRoomBelow && isCurrentlyAbove) {
        newDirection = 'below';
      }
  
      if (newDirection == 'above' ||
        (isCurrentlyAbove && newDirection !== 'below')) {
        css.top = container.top - dropdown.height;
      }
  
      if (newDirection != null) {
        this.$dropdown
          .removeClass('select2-dropdown--below select2-dropdown--above')
          .addClass('select2-dropdown--' + newDirection);
        this.$container
          .removeClass('select2-container--below select2-container--above')
          .addClass('select2-container--' + newDirection);
      }
  
      this.$dropdownContainer.css(css);
    };
  
    AttachBody.prototype._resizeDropdown = function () {
      this.$dropdownContainer.width();
  
      var css = {
        width: this.$container.outerWidth(false) + 'px'
      };
  
      if (this.options.get('dropdownAutoWidth')) {
        css.minWidth = css.width;
        css.width = 'auto';
      }
  
      this.$dropdown.css(css);
    };
  
    AttachBody.prototype._showDropdown = function (decorated) {
      this.$dropdownContainer.appendTo(this.$dropdownParent);
  
      this._positionDropdown();
      this._resizeDropdown();
    };
  
    return AttachBody;
  });
  
  S2.define('select2/dropdown/minimumResultsForSearch',[
  
  ], function () {
    function countResults (data) {
      var count = 0;
  
      for (var d = 0; d < data.length; d++) {
        var item = data[d];
  
        if (item.children) {
          count += countResults(item.children);
        } else {
          count++;
        }
      }
  
      return count;
    }
  
    function MinimumResultsForSearch (decorated, $element, options, dataAdapter) {
      this.minimumResultsForSearch = options.get('minimumResultsForSearch');
  
      if (this.minimumResultsForSearch < 0) {
        this.minimumResultsForSearch = Infinity;
      }
  
      decorated.call(this, $element, options, dataAdapter);
    }
  
    MinimumResultsForSearch.prototype.showSearch = function (decorated, params) {
      if (countResults(params.data.results) < this.minimumResultsForSearch) {
        return false;
      }
  
      return decorated.call(this, params);
    };
  
    return MinimumResultsForSearch;
  });
  
  S2.define('select2/dropdown/selectOnClose',[
  
  ], function () {
    function SelectOnClose () { }
  
    SelectOnClose.prototype.bind = function (decorated, container, $container) {
      var self = this;
  
      decorated.call(this, container, $container);
  
      container.on('close', function () {
        self._handleSelectOnClose();
      });
    };
  
    SelectOnClose.prototype._handleSelectOnClose = function () {
      var $highlightedResults = this.getHighlightedResults();
  
      if ($highlightedResults.length < 1) {
        return;
      }
  
      this.trigger('select', {
          data: $highlightedResults.data('data')
      });
    };
  
    return SelectOnClose;
  });
  
  S2.define('select2/dropdown/closeOnSelect',[
  
  ], function () {
    function CloseOnSelect () { }
  
    CloseOnSelect.prototype.bind = function (decorated, container, $container) {
      var self = this;
  
      decorated.call(this, container, $container);
  
      container.on('select', function (evt) {
        self._selectTriggered(evt);
      });
  
      container.on('unselect', function (evt) {
        self._selectTriggered(evt);
      });
    };
  
    CloseOnSelect.prototype._selectTriggered = function (_, evt) {
      var originalEvent = evt.originalEvent;
  
      // Don't close if the control key is being held
      if (originalEvent && originalEvent.ctrlKey) {
        return;
      }
  
      this.trigger('close');
    };
  
    return CloseOnSelect;
  });
  
  S2.define('select2/i18n/en',[],function () {
    // English
    return {
      errorLoading: function () {
        return 'The results could not be loaded.';
      },
      inputTooLong: function (args) {
        var overChars = args.input.length - args.maximum;
  
        var message = 'Please delete ' + overChars + ' character';
  
        if (overChars != 1) {
          message += 's';
        }
  
        return message;
      },
      inputTooShort: function (args) {
        var remainingChars = args.minimum - args.input.length;
  
        var message = 'Please enter ' + remainingChars + ' or more characters';
  
        return message;
      },
      loadingMore: function () {
        return 'Loading more results…';
      },
      maximumSelected: function (args) {
        var message = 'You can only select ' + args.maximum + ' item';
  
        if (args.maximum != 1) {
          message += 's';
        }
  
        return message;
      },
      noResults: function () {
        return 'No results found';
      },
      searching: function () {
        return 'Searching…';
      }
    };
  });
  
  S2.define('select2/defaults',[
    'jquery',
    'require',
  
    './results',
  
    './selection/single',
    './selection/multiple',
    './selection/placeholder',
    './selection/allowClear',
    './selection/search',
    './selection/eventRelay',
  
    './utils',
    './translation',
    './diacritics',
  
    './data/select',
    './data/array',
    './data/ajax',
    './data/tags',
    './data/tokenizer',
    './data/minimumInputLength',
    './data/maximumInputLength',
    './data/maximumSelectionLength',
  
    './dropdown',
    './dropdown/search',
    './dropdown/hidePlaceholder',
    './dropdown/infiniteScroll',
    './dropdown/attachBody',
    './dropdown/minimumResultsForSearch',
    './dropdown/selectOnClose',
    './dropdown/closeOnSelect',
  
    './i18n/en'
  ], function ($, require,
  
               ResultsList,
  
               SingleSelection, MultipleSelection, Placeholder, AllowClear,
               SelectionSearch, EventRelay,
  
               Utils, Translation, DIACRITICS,
  
               SelectData, ArrayData, AjaxData, Tags, Tokenizer,
               MinimumInputLength, MaximumInputLength, MaximumSelectionLength,
  
               Dropdown, DropdownSearch, HidePlaceholder, InfiniteScroll,
               AttachBody, MinimumResultsForSearch, SelectOnClose, CloseOnSelect,
  
               EnglishTranslation) {
    function Defaults () {
      this.reset();
    }
  
    Defaults.prototype.apply = function (options) {
      options = $.extend({}, this.defaults, options);
  
      if (options.dataAdapter == null) {
        if (options.ajax != null) {
          options.dataAdapter = AjaxData;
        } else if (options.data != null) {
          options.dataAdapter = ArrayData;
        } else {
          options.dataAdapter = SelectData;
        }
  
        if (options.minimumInputLength > 0) {
          options.dataAdapter = Utils.Decorate(
            options.dataAdapter,
            MinimumInputLength
          );
        }
  
        if (options.maximumInputLength > 0) {
          options.dataAdapter = Utils.Decorate(
            options.dataAdapter,
            MaximumInputLength
          );
        }
  
        if (options.maximumSelectionLength > 0) {
          options.dataAdapter = Utils.Decorate(
            options.dataAdapter,
            MaximumSelectionLength
          );
        }
  
        if (options.tags) {
          options.dataAdapter = Utils.Decorate(options.dataAdapter, Tags);
        }
  
        if (options.tokenSeparators != null || options.tokenizer != null) {
          options.dataAdapter = Utils.Decorate(
            options.dataAdapter,
            Tokenizer
          );
        }
  
        if (options.query != null) {
          var Query = require(options.amdBase + 'compat/query');
  
          options.dataAdapter = Utils.Decorate(
            options.dataAdapter,
            Query
          );
        }
  
        if (options.initSelection != null) {
          var InitSelection = require(options.amdBase + 'compat/initSelection');
  
          options.dataAdapter = Utils.Decorate(
            options.dataAdapter,
            InitSelection
          );
        }
      }
  
      if (options.resultsAdapter == null) {
        options.resultsAdapter = ResultsList;
  
        if (options.ajax != null) {
          options.resultsAdapter = Utils.Decorate(
            options.resultsAdapter,
            InfiniteScroll
          );
        }
  
        if (options.placeholder != null) {
          options.resultsAdapter = Utils.Decorate(
            options.resultsAdapter,
            HidePlaceholder
          );
        }
  
        if (options.selectOnClose) {
          options.resultsAdapter = Utils.Decorate(
            options.resultsAdapter,
            SelectOnClose
          );
        }
      }
  
      if (options.dropdownAdapter == null) {
        if (options.multiple) {
          options.dropdownAdapter = Dropdown;
        } else {
          var SearchableDropdown = Utils.Decorate(Dropdown, DropdownSearch);
  
          options.dropdownAdapter = SearchableDropdown;
        }
  
        if (options.minimumResultsForSearch !== 0) {
          options.dropdownAdapter = Utils.Decorate(
            options.dropdownAdapter,
            MinimumResultsForSearch
          );
        }
  
        if (options.closeOnSelect) {
          options.dropdownAdapter = Utils.Decorate(
            options.dropdownAdapter,
            CloseOnSelect
          );
        }
  
        if (
          options.dropdownCssClass != null ||
          options.dropdownCss != null ||
          options.adaptDropdownCssClass != null
        ) {
          var DropdownCSS = require(options.amdBase + 'compat/dropdownCss');
  
          options.dropdownAdapter = Utils.Decorate(
            options.dropdownAdapter,
            DropdownCSS
          );
        }
  
        options.dropdownAdapter = Utils.Decorate(
          options.dropdownAdapter,
          AttachBody
        );
      }
  
      if (options.selectionAdapter == null) {
        if (options.multiple) {
          options.selectionAdapter = MultipleSelection;
        } else {
          options.selectionAdapter = SingleSelection;
        }
  
        // Add the placeholder mixin if a placeholder was specified
        if (options.placeholder != null) {
          options.selectionAdapter = Utils.Decorate(
            options.selectionAdapter,
            Placeholder
          );
        }
  
        if (options.allowClear) {
          options.selectionAdapter = Utils.Decorate(
            options.selectionAdapter,
            AllowClear
          );
        }
  
        if (options.multiple) {
          options.selectionAdapter = Utils.Decorate(
            options.selectionAdapter,
            SelectionSearch
          );
        }
  
        if (
          options.containerCssClass != null ||
          options.containerCss != null ||
          options.adaptContainerCssClass != null
        ) {
          var ContainerCSS = require(options.amdBase + 'compat/containerCss');
  
          options.selectionAdapter = Utils.Decorate(
            options.selectionAdapter,
            ContainerCSS
          );
        }
  
        options.selectionAdapter = Utils.Decorate(
          options.selectionAdapter,
          EventRelay
        );
      }
  
      if (typeof options.language === 'string') {
        // Check if the language is specified with a region
        if (options.language.indexOf('-') > 0) {
          // Extract the region information if it is included
          var languageParts = options.language.split('-');
          var baseLanguage = languageParts[0];
  
          options.language = [options.language, baseLanguage];
        } else {
          options.language = [options.language];
        }
      }
  
      if ($.isArray(options.language)) {
        var languages = new Translation();
        options.language.push('en');
  
        var languageNames = options.language;
  
        for (var l = 0; l < languageNames.length; l++) {
          var name = languageNames[l];
          var language = {};
  
          try {
            // Try to load it with the original name
            language = Translation.loadPath(name);
          } catch (e) {
            try {
              // If we couldn't load it, check if it wasn't the full path
              name = this.defaults.amdLanguageBase + name;
              language = Translation.loadPath(name);
            } catch (ex) {
              // The translation could not be loaded at all. Sometimes this is
              // because of a configuration problem, other times this can be
              // because of how Select2 helps load all possible translation files.
              if (options.debug && window.console && console.warn) {
                console.warn(
                  'Select2: The language file for "' + name + '" could not be ' +
                  'automatically loaded. A fallback will be used instead.'
                );
              }
  
              continue;
            }
          }
  
          languages.extend(language);
        }
  
        options.translations = languages;
      } else {
        var baseTranslation = Translation.loadPath(
          this.defaults.amdLanguageBase + 'en'
        );
        var customTranslation = new Translation(options.language);
  
        customTranslation.extend(baseTranslation);
  
        options.translations = customTranslation;
      }
  
      return options;
    };
  
    Defaults.prototype.reset = function () {
      function stripDiacritics (text) {
        // Used 'uni range + named function' from http://jsperf.com/diacritics/18
        function match(a) {
          return DIACRITICS[a] || a;
        }
  
        return text.replace(/[^\u0000-\u007E]/g, match);
      }
  
      function matcher (params, data) {
        // Always return the object if there is nothing to compare
        if ($.trim(params.term) === '') {
          return data;
        }
  
        // Do a recursive check for options with children
        if (data.children && data.children.length > 0) {
          // Clone the data object if there are children
          // This is required as we modify the object to remove any non-matches
          var match = $.extend(true, {}, data);
  
          // Check each child of the option
          for (var c = data.children.length - 1; c >= 0; c--) {
            var child = data.children[c];
  
            var matches = matcher(params, child);
  
            // If there wasn't a match, remove the object in the array
            if (matches == null) {
              match.children.splice(c, 1);
            }
          }
  
          // If any children matched, return the new object
          if (match.children.length > 0) {
            return match;
          }
  
          // If there were no matching children, check just the plain object
          return matcher(params, match);
        }
  
        var original = stripDiacritics(data.text).toUpperCase();
        var term = stripDiacritics(params.term).toUpperCase();
  
        // Check if the text contains the term
        if (original.indexOf(term) > -1) {
          return data;
        }
  
        // If it doesn't contain the term, don't return anything
        return null;
      }
  
      this.defaults = {
        amdBase: './',
        amdLanguageBase: './i18n/',
        closeOnSelect: true,
        debug: false,
        dropdownAutoWidth: false,
        escapeMarkup: Utils.escapeMarkup,
        language: EnglishTranslation,
        matcher: matcher,
        minimumInputLength: 0,
        maximumInputLength: 0,
        maximumSelectionLength: 0,
        minimumResultsForSearch: 0,
        selectOnClose: false,
        sorter: function (data) {
          return data;
        },
        templateResult: function (result) {
          return result.text;
        },
        templateSelection: function (selection) {
          return selection.text;
        },
        theme: 'default',
        width: 'resolve'
      };
    };
  
    Defaults.prototype.set = function (key, value) {
      var camelKey = $.camelCase(key);
  
      var data = {};
      data[camelKey] = value;
  
      var convertedData = Utils._convertData(data);
  
      $.extend(this.defaults, convertedData);
    };
  
    var defaults = new Defaults();
  
    return defaults;
  });
  
  S2.define('select2/options',[
    'require',
    'jquery',
    './defaults',
    './utils'
  ], function (require, $, Defaults, Utils) {
    function Options (options, $element) {
      this.options = options;
  
      if ($element != null) {
        this.fromElement($element);
      }
  
      this.options = Defaults.apply(this.options);
  
      if ($element && $element.is('input')) {
        var InputCompat = require(this.get('amdBase') + 'compat/inputData');
  
        this.options.dataAdapter = Utils.Decorate(
          this.options.dataAdapter,
          InputCompat
        );
      }
    }
  
    Options.prototype.fromElement = function ($e) {
      var excludedData = ['select2'];
  
      if (this.options.multiple == null) {
        this.options.multiple = $e.prop('multiple');
      }
  
      if (this.options.disabled == null) {
        this.options.disabled = $e.prop('disabled');
      }
  
      if (this.options.language == null) {
        if ($e.prop('lang')) {
          this.options.language = $e.prop('lang').toLowerCase();
        } else if ($e.closest('[lang]').prop('lang')) {
          this.options.language = $e.closest('[lang]').prop('lang');
        }
      }
  
      if (this.options.dir == null) {
        if ($e.prop('dir')) {
          this.options.dir = $e.prop('dir');
        } else if ($e.closest('[dir]').prop('dir')) {
          this.options.dir = $e.closest('[dir]').prop('dir');
        } else {
          this.options.dir = 'ltr';
        }
      }
  
      $e.prop('disabled', this.options.disabled);
      $e.prop('multiple', this.options.multiple);
  
      if ($e.data('select2Tags')) {
        if (this.options.debug && window.console && console.warn) {
          console.warn(
            'Select2: The `data-select2-tags` attribute has been changed to ' +
            'use the `data-data` and `data-tags="true"` attributes and will be ' +
            'removed in future versions of Select2.'
          );
        }
  
        $e.data('data', $e.data('select2Tags'));
        $e.data('tags', true);
      }
  
      if ($e.data('ajaxUrl')) {
        if (this.options.debug && window.console && console.warn) {
          console.warn(
            'Select2: The `data-ajax-url` attribute has been changed to ' +
            '`data-ajax--url` and support for the old attribute will be removed' +
            ' in future versions of Select2.'
          );
        }
  
        $e.attr('ajax--url', $e.data('ajaxUrl'));
        $e.data('ajax--url', $e.data('ajaxUrl'));
      }
  
      var dataset = {};
  
      // Prefer the element's `dataset` attribute if it exists
      // jQuery 1.x does not correctly handle data attributes with multiple dashes
      if ($.fn.jquery && $.fn.jquery.substr(0, 2) == '1.' && $e[0].dataset) {
        dataset = $.extend(true, {}, $e[0].dataset, $e.data());
      } else {
        dataset = $e.data();
      }
  
      var data = $.extend(true, {}, dataset);
  
      data = Utils._convertData(data);
  
      for (var key in data) {
        if ($.inArray(key, excludedData) > -1) {
          continue;
        }
  
        if ($.isPlainObject(this.options[key])) {
          $.extend(this.options[key], data[key]);
        } else {
          this.options[key] = data[key];
        }
      }
  
      return this;
    };
  
    Options.prototype.get = function (key) {
      return this.options[key];
    };
  
    Options.prototype.set = function (key, val) {
      this.options[key] = val;
    };
  
    return Options;
  });
  
  S2.define('select2/core',[
    'jquery',
    './options',
    './utils',
    './keys'
  ], function ($, Options, Utils, KEYS) {
    var Select2 = function ($element, options) {
      if ($element.data('select2') != null) {
        $element.data('select2').destroy();
      }
  
      this.$element = $element;
  
      this.id = this._generateId($element);
  
      options = options || {};
  
      this.options = new Options(options, $element);
  
      Select2.__super__.constructor.call(this);
  
      // Set up the tabindex
  
      var tabindex = $element.attr('tabindex') || 0;
      $element.data('old-tabindex', tabindex);
      $element.attr('tabindex', '-1');
  
      // Set up containers and adapters
  
      var DataAdapter = this.options.get('dataAdapter');
      this.dataAdapter = new DataAdapter($element, this.options);
  
      var $container = this.render();
  
      this._placeContainer($container);
  
      var SelectionAdapter = this.options.get('selectionAdapter');
      this.selection = new SelectionAdapter($element, this.options);
      this.$selection = this.selection.render();
  
      this.selection.position(this.$selection, $container);
  
      var DropdownAdapter = this.options.get('dropdownAdapter');
      this.dropdown = new DropdownAdapter($element, this.options);
      this.$dropdown = this.dropdown.render();
  
      this.dropdown.position(this.$dropdown, $container);
  
      var ResultsAdapter = this.options.get('resultsAdapter');
      this.results = new ResultsAdapter($element, this.options, this.dataAdapter);
      this.$results = this.results.render();
  
      this.results.position(this.$results, this.$dropdown);
  
      // Bind events
  
      var self = this;
  
      // Bind the container to all of the adapters
      this._bindAdapters();
  
      // Register any DOM event handlers
      this._registerDomEvents();
  
      // Register any internal event handlers
      this._registerDataEvents();
      this._registerSelectionEvents();
      this._registerDropdownEvents();
      this._registerResultsEvents();
      this._registerEvents();
  
      // Set the initial state
      this.dataAdapter.current(function (initialData) {
        self.trigger('selection:update', {
          data: initialData
        });
      });
  
      // Hide the original select
      $element.addClass('select2-hidden-accessible');
  	$element.attr('aria-hidden', 'true');
  	
      // Synchronize any monitored attributes
      this._syncAttributes();
  
      $element.data('select2', this);
    };
  
    Utils.Extend(Select2, Utils.Observable);
  
    Select2.prototype._generateId = function ($element) {
      var id = '';
  
      if ($element.attr('id') != null) {
        id = $element.attr('id');
      } else if ($element.attr('name') != null) {
        id = $element.attr('name') + '-' + Utils.generateChars(2);
      } else {
        id = Utils.generateChars(4);
      }
  
      id = 'select2-' + id;
  
      return id;
    };
  
    Select2.prototype._placeContainer = function ($container) {
      $container.insertAfter(this.$element);
  
      var width = this._resolveWidth(this.$element, this.options.get('width'));
  
      if (width != null) {
        $container.css('width', width);
      }
    };
  
    Select2.prototype._resolveWidth = function ($element, method) {
      var WIDTH = /^width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/i;
  
      if (method == 'resolve') {
        var styleWidth = this._resolveWidth($element, 'style');
  
        if (styleWidth != null) {
          return styleWidth;
        }
  
        return this._resolveWidth($element, 'element');
      }
  
      if (method == 'element') {
        var elementWidth = $element.outerWidth(false);
  
        if (elementWidth <= 0) {
          return 'auto';
        }
  
        return elementWidth + 'px';
      }
  
      if (method == 'style') {
        var style = $element.attr('style');
  
        if (typeof(style) !== 'string') {
          return null;
        }
  
        var attrs = style.split(';');
  
        for (var i = 0, l = attrs.length; i < l; i = i + 1) {
          var attr = attrs[i].replace(/\s/g, '');
          var matches = attr.match(WIDTH);
  
          if (matches !== null && matches.length >= 1) {
            return matches[1];
          }
        }
  
        return null;
      }
  
      return method;
    };
  
    Select2.prototype._bindAdapters = function () {
      this.dataAdapter.bind(this, this.$container);
      this.selection.bind(this, this.$container);
  
      this.dropdown.bind(this, this.$container);
      this.results.bind(this, this.$container);
    };
  
    Select2.prototype._registerDomEvents = function () {
      var self = this;
  
      this.$element.on('change.select2', function () {
        self.dataAdapter.current(function (data) {
          self.trigger('selection:update', {
            data: data
          });
        });
      });
  
      this._sync = Utils.bind(this._syncAttributes, this);
  
      if (this.$element[0].attachEvent) {
        this.$element[0].attachEvent('onpropertychange', this._sync);
      }
  
      var observer = window.MutationObserver ||
        window.WebKitMutationObserver ||
        window.MozMutationObserver
      ;
  
      if (observer != null) {
        this._observer = new observer(function (mutations) {
          $.each(mutations, self._sync);
        });
        this._observer.observe(this.$element[0], {
          attributes: true,
          subtree: false
        });
      } else if (this.$element[0].addEventListener) {
        this.$element[0].addEventListener('DOMAttrModified', self._sync, false);
      }
    };
  
    Select2.prototype._registerDataEvents = function () {
      var self = this;
  
      this.dataAdapter.on('*', function (name, params) {
        self.trigger(name, params);
      });
    };
  
    Select2.prototype._registerSelectionEvents = function () {
      var self = this;
      var nonRelayEvents = ['toggle'];
  
      this.selection.on('toggle', function () {
        self.toggleDropdown();
      });
  
      this.selection.on('*', function (name, params) {
        if ($.inArray(name, nonRelayEvents) !== -1) {
          return;
        }
  
        self.trigger(name, params);
      });
    };
  
    Select2.prototype._registerDropdownEvents = function () {
      var self = this;
  
      this.dropdown.on('*', function (name, params) {
        self.trigger(name, params);
      });
    };
  
    Select2.prototype._registerResultsEvents = function () {
      var self = this;
  
      this.results.on('*', function (name, params) {
        self.trigger(name, params);
      });
    };
  
    Select2.prototype._registerEvents = function () {
      var self = this;
  
      this.on('open', function () {
        self.$container.addClass('select2-container--open');
      });
  
      this.on('close', function () {
        self.$container.removeClass('select2-container--open');
      });
  
      this.on('enable', function () {
        self.$container.removeClass('select2-container--disabled');
      });
  
      this.on('disable', function () {
        self.$container.addClass('select2-container--disabled');
      });
  
      this.on('focus', function () {
        self.$container.addClass('select2-container--focus');
      });
  
      this.on('blur', function () {
        self.$container.removeClass('select2-container--focus');
      });
  
      this.on('query', function (params) {
        if (!self.isOpen()) {
          self.trigger('open');
        }
  
        this.dataAdapter.query(params, function (data) {
          self.trigger('results:all', {
            data: data,
            query: params
          });
        });
      });
  
      this.on('query:append', function (params) {
        this.dataAdapter.query(params, function (data) {
          self.trigger('results:append', {
            data: data,
            query: params
          });
        });
      });
  
      this.on('keypress', function (evt) {
        var key = evt.which;
  
        if (self.isOpen()) {
          if (key === KEYS.ENTER) {
            self.trigger('results:select');
  
            evt.preventDefault();
          } else if ((key === KEYS.SPACE && evt.ctrlKey)) {
            self.trigger('results:toggle');
  
            evt.preventDefault();
          } else if (key === KEYS.UP) {
            self.trigger('results:previous');
  
            evt.preventDefault();
          } else if (key === KEYS.DOWN) {
            self.trigger('results:next');
  
            evt.preventDefault();
          } else if (key === KEYS.ESC || key === KEYS.TAB) {
            self.close();
  
            evt.preventDefault();
          }
        } else {
          if (key === KEYS.ENTER || key === KEYS.SPACE ||
              ((key === KEYS.DOWN || key === KEYS.UP) && evt.altKey)) {
            self.open();
  
            evt.preventDefault();
          }
        }
      });
    };
  
    Select2.prototype._syncAttributes = function () {
      this.options.set('disabled', this.$element.prop('disabled'));
  
      if (this.options.get('disabled')) {
        if (this.isOpen()) {
          this.close();
        }
  
        this.trigger('disable');
      } else {
        this.trigger('enable');
      }
    };
  
    /**
     * Override the trigger method to automatically trigger pre-events when
     * there are events that can be prevented.
     */
    Select2.prototype.trigger = function (name, args) {
      var actualTrigger = Select2.__super__.trigger;
      var preTriggerMap = {
        'open': 'opening',
        'close': 'closing',
        'select': 'selecting',
        'unselect': 'unselecting'
      };
  
      if (name in preTriggerMap) {
        var preTriggerName = preTriggerMap[name];
        var preTriggerArgs = {
          prevented: false,
          name: name,
          args: args
        };
  
        actualTrigger.call(this, preTriggerName, preTriggerArgs);
  
        if (preTriggerArgs.prevented) {
          args.prevented = true;
  
          return;
        }
      }
  
      actualTrigger.call(this, name, args);
    };
  
    Select2.prototype.toggleDropdown = function () {
      if (this.options.get('disabled')) {
        return;
      }
  
      if (this.isOpen()) {
        this.close();
      } else {
        this.open();
      }
    };
  
    Select2.prototype.open = function () {
      if (this.isOpen()) {
        return;
      }
  
      this.trigger('query', {});
  
      this.trigger('open');
    };
  
    Select2.prototype.close = function () {
      if (!this.isOpen()) {
        return;
      }
  
      this.trigger('close');
    };
  
    Select2.prototype.isOpen = function () {
      return this.$container.hasClass('select2-container--open');
    };
  
    Select2.prototype.enable = function (args) {
      if (this.options.get('debug') && window.console && console.warn) {
        console.warn(
          'Select2: The `select2("enable")` method has been deprecated and will' +
          ' be removed in later Select2 versions. Use $element.prop("disabled")' +
          ' instead.'
        );
      }
  
      if (args == null || args.length === 0) {
        args = [true];
      }
  
      var disabled = !args[0];
  
      this.$element.prop('disabled', disabled);
    };
  
    Select2.prototype.data = function () {
      if (this.options.get('debug') &&
          arguments.length > 0 && window.console && console.warn) {
        console.warn(
          'Select2: Data can no longer be set using `select2("data")`. You ' +
          'should consider setting the value instead using `$element.val()`.'
        );
      }
  
      var data = [];
  
      this.dataAdapter.current(function (currentData) {
        data = currentData;
      });
  
      return data;
    };
  
    Select2.prototype.val = function (args) {
      if (this.options.get('debug') && window.console && console.warn) {
        console.warn(
          'Select2: The `select2("val")` method has been deprecated and will be' +
          ' removed in later Select2 versions. Use $element.val() instead.'
        );
      }
  
      if (args == null || args.length === 0) {
        return this.$element.val();
      }
  
      var newVal = args[0];
  
      if ($.isArray(newVal)) {
        newVal = $.map(newVal, function (obj) {
          return obj.toString();
        });
      }
  
      this.$element.val(newVal).trigger('change');
    };
  
    Select2.prototype.destroy = function () {
      this.$container.remove();
  
      if (this.$element[0].detachEvent) {
        this.$element[0].detachEvent('onpropertychange', this._sync);
      }
  
      if (this._observer != null) {
        this._observer.disconnect();
        this._observer = null;
      } else if (this.$element[0].removeEventListener) {
        this.$element[0]
          .removeEventListener('DOMAttrModified', this._sync, false);
      }
  
      this._sync = null;
  
      this.$element.off('.select2');
      this.$element.attr('tabindex', this.$element.data('old-tabindex'));
  
      this.$element.removeClass('select2-hidden-accessible');
  	this.$element.attr('aria-hidden', 'false');
      this.$element.removeData('select2');
  
      this.dataAdapter.destroy();
      this.selection.destroy();
      this.dropdown.destroy();
      this.results.destroy();
  
      this.dataAdapter = null;
      this.selection = null;
      this.dropdown = null;
      this.results = null;
    };
  
    Select2.prototype.render = function () {
      var $container = $(
        '<span class="select2 select2-container">' +
          '<span class="selection"></span>' +
          '<span class="dropdown-wrapper" aria-hidden="true"></span>' +
        '</span>'
      );
  
      $container.attr('dir', this.options.get('dir'));
  
      this.$container = $container;
  
      this.$container.addClass('select2-container--' + this.options.get('theme'));
  
      $container.data('element', this.$element);
  
      return $container;
    };
  
    return Select2;
  });
  
  S2.define('select2/compat/utils',[
    'jquery'
  ], function ($) {
    function syncCssClasses ($dest, $src, adapter) {
      var classes, replacements = [], adapted;
  
      classes = $.trim($dest.attr('class'));
  
      if (classes) {
        classes = '' + classes; // for IE which returns object
  
        $(classes.split(/\s+/)).each(function () {
          // Save all Select2 classes
          if (this.indexOf('select2-') === 0) {
            replacements.push(this);
          }
        });
      }
  
      classes = $.trim($src.attr('class'));
  
      if (classes) {
        classes = '' + classes; // for IE which returns object
  
        $(classes.split(/\s+/)).each(function () {
          // Only adapt non-Select2 classes
          if (this.indexOf('select2-') !== 0) {
            adapted = adapter(this);
  
            if (adapted != null) {
              replacements.push(adapted);
            }
          }
        });
      }
  
      $dest.attr('class', replacements.join(' '));
    }
  
    return {
      syncCssClasses: syncCssClasses
    };
  });
  
  S2.define('select2/compat/containerCss',[
    'jquery',
    './utils'
  ], function ($, CompatUtils) {
    // No-op CSS adapter that discards all classes by default
    function _containerAdapter (clazz) {
      return null;
    }
  
    function ContainerCSS () { }
  
    ContainerCSS.prototype.render = function (decorated) {
      var $container = decorated.call(this);
  
      var containerCssClass = this.options.get('containerCssClass') || '';
  
      if ($.isFunction(containerCssClass)) {
        containerCssClass = containerCssClass(this.$element);
      }
  
      var containerCssAdapter = this.options.get('adaptContainerCssClass');
      containerCssAdapter = containerCssAdapter || _containerAdapter;
  
      if (containerCssClass.indexOf(':all:') !== -1) {
        containerCssClass = containerCssClass.replace(':all', '');
  
        var _cssAdapter = containerCssAdapter;
  
        containerCssAdapter = function (clazz) {
          var adapted = _cssAdapter(clazz);
  
          if (adapted != null) {
            // Append the old one along with the adapted one
            return adapted + ' ' + clazz;
          }
  
          return clazz;
        };
      }
  
      var containerCss = this.options.get('containerCss') || {};
  
      if ($.isFunction(containerCss)) {
        containerCss = containerCss(this.$element);
      }
  
      CompatUtils.syncCssClasses($container, this.$element, containerCssAdapter);
  
      $container.css(containerCss);
      $container.addClass(containerCssClass);
  
      return $container;
    };
  
    return ContainerCSS;
  });
  
  S2.define('select2/compat/dropdownCss',[
    'jquery',
    './utils'
  ], function ($, CompatUtils) {
    // No-op CSS adapter that discards all classes by default
    function _dropdownAdapter (clazz) {
      return null;
    }
  
    function DropdownCSS () { }
  
    DropdownCSS.prototype.render = function (decorated) {
      var $dropdown = decorated.call(this);
  
      var dropdownCssClass = this.options.get('dropdownCssClass') || '';
  
      if ($.isFunction(dropdownCssClass)) {
        dropdownCssClass = dropdownCssClass(this.$element);
      }
  
      var dropdownCssAdapter = this.options.get('adaptDropdownCssClass');
      dropdownCssAdapter = dropdownCssAdapter || _dropdownAdapter;
  
      if (dropdownCssClass.indexOf(':all:') !== -1) {
        dropdownCssClass = dropdownCssClass.replace(':all', '');
  
        var _cssAdapter = dropdownCssAdapter;
  
        dropdownCssAdapter = function (clazz) {
          var adapted = _cssAdapter(clazz);
  
          if (adapted != null) {
            // Append the old one along with the adapted one
            return adapted + ' ' + clazz;
          }
  
          return clazz;
        };
      }
  
      var dropdownCss = this.options.get('dropdownCss') || {};
  
      if ($.isFunction(dropdownCss)) {
        dropdownCss = dropdownCss(this.$element);
      }
  
      CompatUtils.syncCssClasses($dropdown, this.$element, dropdownCssAdapter);
  
      $dropdown.css(dropdownCss);
      $dropdown.addClass(dropdownCssClass);
  
      return $dropdown;
    };
  
    return DropdownCSS;
  });
  
  S2.define('select2/compat/initSelection',[
    'jquery'
  ], function ($) {
    function InitSelection (decorated, $element, options) {
      if (options.get('debug') && window.console && console.warn) {
        console.warn(
          'Select2: The `initSelection` option has been deprecated in favor' +
          ' of a custom data adapter that overrides the `current` method. ' +
          'This method is now called multiple times instead of a single ' +
          'time when the instance is initialized. Support will be removed ' +
          'for the `initSelection` option in future versions of Select2'
        );
      }
  
      this.initSelection = options.get('initSelection');
      this._isInitialized = false;
  
      decorated.call(this, $element, options);
    }
  
    InitSelection.prototype.current = function (decorated, callback) {
      var self = this;
  
      if (this._isInitialized) {
        decorated.call(this, callback);
  
        return;
      }
  
      this.initSelection.call(null, this.$element, function (data) {
        self._isInitialized = true;
  
        if (!$.isArray(data)) {
          data = [data];
        }
  
        callback(data);
      });
    };
  
    return InitSelection;
  });
  
  S2.define('select2/compat/inputData',[
    'jquery'
  ], function ($) {
    function InputData (decorated, $element, options) {
      this._currentData = [];
      this._valueSeparator = options.get('valueSeparator') || ',';
  
      if ($element.prop('type') === 'hidden') {
        if (options.get('debug') && console && console.warn) {
          console.warn(
            'Select2: Using a hidden input with Select2 is no longer ' +
            'supported and may stop working in the future. It is recommended ' +
            'to use a `<select>` element instead.'
          );
        }
      }
  
      decorated.call(this, $element, options);
    }
  
    InputData.prototype.current = function (_, callback) {
      function getSelected (data, selectedIds) {
        var selected = [];
  
        if (data.selected || $.inArray(data.id, selectedIds) !== -1) {
          data.selected = true;
          selected.push(data);
        } else {
          data.selected = false;
        }
  
        if (data.children) {
          selected.push.apply(selected, getSelected(data.children, selectedIds));
        }
  
        return selected;
      }
  
      var selected = [];
  
      for (var d = 0; d < this._currentData.length; d++) {
        var data = this._currentData[d];
  
        selected.push.apply(
          selected,
          getSelected(
            data,
            this.$element.val().split(
              this._valueSeparator
            )
          )
        );
      }
  
      callback(selected);
    };
  
    InputData.prototype.select = function (_, data) {
      if (!this.options.get('multiple')) {
        this.current(function (allData) {
          $.map(allData, function (data) {
            data.selected = false;
          });
        });
  
        this.$element.val(data.id);
        this.$element.trigger('change');
      } else {
        var value = this.$element.val();
        value += this._valueSeparator + data.id;
  
        this.$element.val(value);
        this.$element.trigger('change');
      }
    };
  
    InputData.prototype.unselect = function (_, data) {
      var self = this;
  
      data.selected = false;
  
      this.current(function (allData) {
        var values = [];
  
        for (var d = 0; d < allData.length; d++) {
          var item = allData[d];
  
          if (data.id == item.id) {
            continue;
          }
  
          values.push(item.id);
        }
  
        self.$element.val(values.join(self._valueSeparator));
        self.$element.trigger('change');
      });
    };
  
    InputData.prototype.query = function (_, params, callback) {
      var results = [];
  
      for (var d = 0; d < this._currentData.length; d++) {
        var data = this._currentData[d];
  
        var matches = this.matches(params, data);
  
        if (matches !== null) {
          results.push(matches);
        }
      }
  
      callback({
        results: results
      });
    };
  
    InputData.prototype.addOptions = function (_, $options) {
      var options = $.map($options, function ($option) {
        return $.data($option[0], 'data');
      });
  
      this._currentData.push.apply(this._currentData, options);
    };
  
    return InputData;
  });
  
  S2.define('select2/compat/matcher',[
    'jquery'
  ], function ($) {
    function oldMatcher (matcher) {
      function wrappedMatcher (params, data) {
        var match = $.extend(true, {}, data);
  
        if (params.term == null || $.trim(params.term) === '') {
          return match;
        }
  
        if (data.children) {
          for (var c = data.children.length - 1; c >= 0; c--) {
            var child = data.children[c];
  
            // Check if the child object matches
            // The old matcher returned a boolean true or false
            var doesMatch = matcher(params.term, child.text, child);
  
            // If the child didn't match, pop it off
            if (!doesMatch) {
              match.children.splice(c, 1);
            }
          }
  
          if (match.children.length > 0) {
            return match;
          }
        }
  
        if (matcher(params.term, data.text, data)) {
          return match;
        }
  
        return null;
      }
  
      return wrappedMatcher;
    }
  
    return oldMatcher;
  });
  
  S2.define('select2/compat/query',[
  
  ], function () {
    function Query (decorated, $element, options) {
      if (options.get('debug') && window.console && console.warn) {
        console.warn(
          'Select2: The `query` option has been deprecated in favor of a ' +
          'custom data adapter that overrides the `query` method. Support ' +
          'will be removed for the `query` option in future versions of ' +
          'Select2.'
        );
      }
  
      decorated.call(this, $element, options);
    }
  
    Query.prototype.query = function (_, params, callback) {
      params.callback = callback;
  
      var query = this.options.get('query');
  
      query.call(null, params);
    };
  
    return Query;
  });
  
  S2.define('select2/dropdown/attachContainer',[
  
  ], function () {
    function AttachContainer (decorated, $element, options) {
      decorated.call(this, $element, options);
    }
  
    AttachContainer.prototype.position =
      function (decorated, $dropdown, $container) {
      var $dropdownContainer = $container.find('.dropdown-wrapper');
      $dropdownContainer.append($dropdown);
  
      $dropdown.addClass('select2-dropdown--below');
      $container.addClass('select2-container--below');
    };
  
    return AttachContainer;
  });
  
  S2.define('select2/dropdown/stopPropagation',[
  
  ], function () {
    function StopPropagation () { }
  
    StopPropagation.prototype.bind = function (decorated, container, $container) {
      decorated.call(this, container, $container);
  
      var stoppedEvents = [
      'blur',
      'change',
      'click',
      'dblclick',
      'focus',
      'focusin',
      'focusout',
      'input',
      'keydown',
      'keyup',
      'keypress',
      'mousedown',
      'mouseenter',
      'mouseleave',
      'mousemove',
      'mouseover',
      'mouseup',
      'search',
      'touchend',
      'touchstart'
      ];
  
      this.$dropdown.on(stoppedEvents.join(' '), function (evt) {
        evt.stopPropagation();
      });
    };
  
    return StopPropagation;
  });
  
  S2.define('select2/selection/stopPropagation',[
  
  ], function () {
    function StopPropagation () { }
  
    StopPropagation.prototype.bind = function (decorated, container, $container) {
      decorated.call(this, container, $container);
  
      var stoppedEvents = [
        'blur',
        'change',
        'click',
        'dblclick',
        'focus',
        'focusin',
        'focusout',
        'input',
        'keydown',
        'keyup',
        'keypress',
        'mousedown',
        'mouseenter',
        'mouseleave',
        'mousemove',
        'mouseover',
        'mouseup',
        'search',
        'touchend',
        'touchstart'
      ];
  
      this.$selection.on(stoppedEvents.join(' '), function (evt) {
        evt.stopPropagation();
      });
    };
  
    return StopPropagation;
  });
  
  S2.define('jquery.select2',[
    'jquery',
    'require',
  
    './select2/core',
    './select2/defaults'
  ], function ($, require, Select2, Defaults) {
    // Force jQuery.mousewheel to be loaded if it hasn't already
    require('jquery.mousewheel');
  
    if ($.fn.select2 == null) {
      // All methods that should return the element
      var thisMethods = ['open', 'close', 'destroy'];
  
      $.fn.select2 = function (options) {
        options = options || {};
  
        if (typeof options === 'object') {
          this.each(function () {
            var instanceOptions = $.extend({}, options, true);
  
            var instance = new Select2($(this), instanceOptions);
          });
  
          return this;
        } else if (typeof options === 'string') {
          var instance = this.data('select2');
  
          if (instance == null && window.console && console.error) {
            console.error(
              'The select2(\'' + options + '\') method was called on an ' +
              'element that is not using Select2.'
            );
          }
  
          var args = Array.prototype.slice.call(arguments, 1);
  
          var ret = instance[options](args);
  
          // Check if we should be returning `this`
          if ($.inArray(options, thisMethods) > -1) {
            return this;
          }
  
          return ret;
        } else {
          throw new Error('Invalid arguments for Select2: ' + options);
        }
      };
    }
  
    if ($.fn.select2.defaults == null) {
      $.fn.select2.defaults = Defaults;
    }
  
    return Select2;
  });
  
  /*!
   * jQuery Mousewheel 3.1.12
   *
   * Copyright 2014 jQuery Foundation and other contributors
   * Released under the MIT license.
   * http://jquery.org/license
   */
  
  (function (factory) {
      if ( typeof S2.define === 'function' && S2.define.amd ) {
          // AMD. Register as an anonymous module.
          S2.define('jquery.mousewheel',['jquery'], factory);
      } else if (typeof exports === 'object') {
          // Node/CommonJS style for Browserify
          module.exports = factory;
      } else {
          // Browser globals
          factory(jQuery);
      }
  }(function ($) {
  
      var toFix  = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll'],
          toBind = ( 'onwheel' in document || document.documentMode >= 9 ) ?
                      ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'],
          slice  = Array.prototype.slice,
          nullLowestDeltaTimeout, lowestDelta;
  
      if ( $.event.fixHooks ) {
          for ( var i = toFix.length; i; ) {
              $.event.fixHooks[ toFix[--i] ] = $.event.mouseHooks;
          }
      }
  
      var special = $.event.special.mousewheel = {
          version: '3.1.12',
  
          setup: function() {
              if ( this.addEventListener ) {
                  for ( var i = toBind.length; i; ) {
                      this.addEventListener( toBind[--i], handler, false );
                  }
              } else {
                  this.onmousewheel = handler;
              }
              // Store the line height and page height for this particular element
              $.data(this, 'mousewheel-line-height', special.getLineHeight(this));
              $.data(this, 'mousewheel-page-height', special.getPageHeight(this));
          },
  
          teardown: function() {
              if ( this.removeEventListener ) {
                  for ( var i = toBind.length; i; ) {
                      this.removeEventListener( toBind[--i], handler, false );
                  }
              } else {
                  this.onmousewheel = null;
              }
              // Clean up the data we added to the element
              $.removeData(this, 'mousewheel-line-height');
              $.removeData(this, 'mousewheel-page-height');
          },
  
          getLineHeight: function(elem) {
              var $elem = $(elem),
                  $parent = $elem['offsetParent' in $.fn ? 'offsetParent' : 'parent']();
              if (!$parent.length) {
                  $parent = $('body');
              }
              return parseInt($parent.css('fontSize'), 10) || parseInt($elem.css('fontSize'), 10) || 16;
          },
  
          getPageHeight: function(elem) {
              return $(elem).height();
          },
  
          settings: {
              adjustOldDeltas: true, // see shouldAdjustOldDeltas() below
              normalizeOffset: true  // calls getBoundingClientRect for each event
          }
      };
  
      $.fn.extend({
          mousewheel: function(fn) {
              return fn ? this.bind('mousewheel', fn) : this.trigger('mousewheel');
          },
  
          unmousewheel: function(fn) {
              return this.unbind('mousewheel', fn);
          }
      });
  
  
      function handler(event) {
          var orgEvent   = event || window.event,
              args       = slice.call(arguments, 1),
              delta      = 0,
              deltaX     = 0,
              deltaY     = 0,
              absDelta   = 0,
              offsetX    = 0,
              offsetY    = 0;
          event = $.event.fix(orgEvent);
          event.type = 'mousewheel';
  
          // Old school scrollwheel delta
          if ( 'detail'      in orgEvent ) { deltaY = orgEvent.detail * -1;      }
          if ( 'wheelDelta'  in orgEvent ) { deltaY = orgEvent.wheelDelta;       }
          if ( 'wheelDeltaY' in orgEvent ) { deltaY = orgEvent.wheelDeltaY;      }
          if ( 'wheelDeltaX' in orgEvent ) { deltaX = orgEvent.wheelDeltaX * -1; }
  
          // Firefox < 17 horizontal scrolling related to DOMMouseScroll event
          if ( 'axis' in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {
              deltaX = deltaY * -1;
              deltaY = 0;
          }
  
          // Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy
          delta = deltaY === 0 ? deltaX : deltaY;
  
          // New school wheel delta (wheel event)
          if ( 'deltaY' in orgEvent ) {
              deltaY = orgEvent.deltaY * -1;
              delta  = deltaY;
          }
          if ( 'deltaX' in orgEvent ) {
              deltaX = orgEvent.deltaX;
              if ( deltaY === 0 ) { delta  = deltaX * -1; }
          }
  
          // No change actually happened, no reason to go any further
          if ( deltaY === 0 && deltaX === 0 ) { return; }
  
          // Need to convert lines and pages to pixels if we aren't already in pixels
          // There are three delta modes:
          //   * deltaMode 0 is by pixels, nothing to do
          //   * deltaMode 1 is by lines
          //   * deltaMode 2 is by pages
          if ( orgEvent.deltaMode === 1 ) {
              var lineHeight = $.data(this, 'mousewheel-line-height');
              delta  *= lineHeight;
              deltaY *= lineHeight;
              deltaX *= lineHeight;
          } else if ( orgEvent.deltaMode === 2 ) {
              var pageHeight = $.data(this, 'mousewheel-page-height');
              delta  *= pageHeight;
              deltaY *= pageHeight;
              deltaX *= pageHeight;
          }
  
          // Store lowest absolute delta to normalize the delta values
          absDelta = Math.max( Math.abs(deltaY), Math.abs(deltaX) );
  
          if ( !lowestDelta || absDelta < lowestDelta ) {
              lowestDelta = absDelta;
  
              // Adjust older deltas if necessary
              if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
                  lowestDelta /= 40;
              }
          }
  
          // Adjust older deltas if necessary
          if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
              // Divide all the things by 40!
              delta  /= 40;
              deltaX /= 40;
              deltaY /= 40;
          }
  
          // Get a whole, normalized value for the deltas
          delta  = Math[ delta  >= 1 ? 'floor' : 'ceil' ](delta  / lowestDelta);
          deltaX = Math[ deltaX >= 1 ? 'floor' : 'ceil' ](deltaX / lowestDelta);
          deltaY = Math[ deltaY >= 1 ? 'floor' : 'ceil' ](deltaY / lowestDelta);
  
          // Normalise offsetX and offsetY properties
          if ( special.settings.normalizeOffset && this.getBoundingClientRect ) {
              var boundingRect = this.getBoundingClientRect();
              offsetX = event.clientX - boundingRect.left;
              offsetY = event.clientY - boundingRect.top;
          }
  
          // Add information to the event object
          event.deltaX = deltaX;
          event.deltaY = deltaY;
          event.deltaFactor = lowestDelta;
          event.offsetX = offsetX;
          event.offsetY = offsetY;
          // Go ahead and set deltaMode to 0 since we converted to pixels
          // Although this is a little odd since we overwrite the deltaX/Y
          // properties with normalized deltas.
          event.deltaMode = 0;
  
          // Add event and delta to the front of the arguments
          args.unshift(event, delta, deltaX, deltaY);
  
          // Clearout lowestDelta after sometime to better
          // handle multiple device types that give different
          // a different lowestDelta
          // Ex: trackpad = 3 and mouse wheel = 120
          if (nullLowestDeltaTimeout) { clearTimeout(nullLowestDeltaTimeout); }
          nullLowestDeltaTimeout = setTimeout(nullLowestDelta, 200);
  
          return ($.event.dispatch || $.event.handle).apply(this, args);
      }
  
      function nullLowestDelta() {
          lowestDelta = null;
      }
  
      function shouldAdjustOldDeltas(orgEvent, absDelta) {
          // If this is an older event and the delta is divisable by 120,
          // then we are assuming that the browser is treating this as an
          // older mouse wheel event and that we should divide the deltas
          // by 40 to try and get a more usable deltaFactor.
          // Side note, this actually impacts the reported scroll distance
          // in older browsers and can cause scrolling to be slower than native.
          // Turn this off by setting $.event.special.mousewheel.settings.adjustOldDeltas to false.
          return special.settings.adjustOldDeltas && orgEvent.type === 'mousewheel' && absDelta % 120 === 0;
      }
  
  }));
  
    // Return the AMD loader configuration so it can be used outside of this file
    return {
      define: S2.define,
      require: S2.require
    };
  }());
  
    // Autoload the jQuery bindings
    // We know that all of the modules exist above this, so we're safe
    var select2 = S2.require('jquery.select2');
  
    // Hold the AMD module references on the jQuery function that was just loaded
    // This allows Select2 to use the internal loader outside of this file, such
    // as in the language files.
    jQuery.fn.select2.amd = S2;
  
    // Return the Select2 instance for anyone who is importing it.
    return select2;
  }));
  
  (function() {
      $(document).ready(function () {
          $('#cliente-select').select2();
      });
  
  })();
  
  /*!
   * Vue.js v0.12.12
   * (c) 2015 Evan You
   * Released under the MIT License.
   */
  (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define(factory);
  	else if(typeof exports === 'object')
  		exports["Vue"] = factory();
  	else
  		root["Vue"] = factory();
  })(this, function() {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  
  
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var extend = _.extend
  
  	/**
  	 * The exposed Vue constructor.
  	 *
  	 * API conventions:
  	 * - public API methods/properties are prefiexed with `$`
  	 * - internal methods/properties are prefixed with `_`
  	 * - non-prefixed properties are assumed to be proxied user
  	 *   data.
  	 *
  	 * @constructor
  	 * @param {Object} [options]
  	 * @public
  	 */
  
  	function Vue (options) {
  	  this._init(options)
  	}
  
  	/**
  	 * Mixin global API
  	 */
  
  	extend(Vue, __webpack_require__(9))
  
  	/**
  	 * 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 = {
  	  replace: true,
  	  directives: __webpack_require__(25),
  	  elementDirectives: __webpack_require__(47),
  	  filters: __webpack_require__(50),
  	  transitions: {},
  	  components: {},
  	  partials: {}
  	}
  
  	/**
  	 * Build up the prototype
  	 */
  
  	var p = Vue.prototype
  
  	/**
  	 * $data has a setter which does a bunch of
  	 * teardown/setup work
  	 */
  
  	Object.defineProperty(p, '$data', {
  	  get: function () {
  	    return this._data
  	  },
  	  set: function (newData) {
  	    if (newData !== this._data) {
  	      this._setData(newData)
  	    }
  	  }
  	})
  
  	/**
  	 * Mixin internal instance methods
  	 */
  
  	extend(p, __webpack_require__(52))
  	extend(p, __webpack_require__(53))
  	extend(p, __webpack_require__(54))
  	extend(p, __webpack_require__(58))
  	extend(p, __webpack_require__(60))
  
  	/**
  	 * Mixin public API methods
  	 */
  
  	extend(p, __webpack_require__(61))
  	extend(p, __webpack_require__(62))
  	extend(p, __webpack_require__(63))
  	extend(p, __webpack_require__(64))
  	extend(p, __webpack_require__(65))
  
  	module.exports = _.Vue = Vue
  
  
  /***/ },
  /* 1 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var lang = __webpack_require__(2)
  	var extend = lang.extend
  
  	extend(exports, lang)
  	extend(exports, __webpack_require__(3))
  	extend(exports, __webpack_require__(4))
  	extend(exports, __webpack_require__(6))
  	extend(exports, __webpack_require__(7))
  	extend(exports, __webpack_require__(8))
  
  
  /***/ },
  /* 2 */
  /***/ function(module, exports) {
  
  	/**
  	 * Check is a string starts with $ or _
  	 *
  	 * @param {String} str
  	 * @return {Boolean}
  	 */
  
  	exports.isReserved = function (str) {
  	  var c = (str + '').charCodeAt(0)
  	  return c === 0x24 || c === 0x5F
  	}
  
  	/**
  	 * Guard text output, make sure undefined outputs
  	 * empty string
  	 *
  	 * @param {*} value
  	 * @return {String}
  	 */
  
  	exports.toString = function (value) {
  	  return value == null
  	    ? ''
  	    : value.toString()
  	}
  
  	/**
  	 * Check and convert possible numeric strings to numbers
  	 * before setting back to data
  	 *
  	 * @param {*} value
  	 * @return {*|Number}
  	 */
  
  	exports.toNumber = function (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}
  	 */
  
  	exports.toBoolean = function (value) {
  	  return value === 'true'
  	    ? true
  	    : value === 'false'
  	      ? false
  	      : value
  	}
  
  	/**
  	 * Strip quotes from a string
  	 *
  	 * @param {String} str
  	 * @return {String | false}
  	 */
  
  	exports.stripQuotes = function (str) {
  	  var a = str.charCodeAt(0)
  	  var b = str.charCodeAt(str.length - 1)
  	  return a === b && (a === 0x22 || a === 0x27)
  	    ? str.slice(1, -1)
  	    : false
  	}
  
  	/**
  	 * Camelize a hyphen-delmited string.
  	 *
  	 * @param {String} str
  	 * @return {String}
  	 */
  
  	exports.camelize = function (str) {
  	  return str.replace(/-(\w)/g, toUpper)
  	}
  
  	function toUpper (_, c) {
  	  return c ? c.toUpperCase() : ''
  	}
  
  	/**
  	 * Hyphenate a camelCase string.
  	 *
  	 * @param {String} str
  	 * @return {String}
  	 */
  
  	exports.hyphenate = function (str) {
  	  return str
  	    .replace(/([a-z\d])([A-Z])/g, '$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
  	exports.classify = function (str) {
  	  return str.replace(classifyRE, toUpper)
  	}
  
  	/**
  	 * Simple bind, faster than native
  	 *
  	 * @param {Function} fn
  	 * @param {Object} ctx
  	 * @return {Function}
  	 */
  
  	exports.bind = function (fn, ctx) {
  	  return function (a) {
  	    var l = arguments.length
  	    return l
  	      ? l > 1
  	        ? fn.apply(ctx, arguments)
  	        : fn.call(ctx, a)
  	      : fn.call(ctx)
  	  }
  	}
  
  	/**
  	 * Convert an Array-like object to a real Array.
  	 *
  	 * @param {Array-like} list
  	 * @param {Number} [start] - start index
  	 * @return {Array}
  	 */
  
  	exports.toArray = function (list, start) {
  	  start = start || 0
  	  var i = list.length - start
  	  var ret = new Array(i)
  	  while (i--) {
  	    ret[i] = list[i + start]
  	  }
  	  return ret
  	}
  
  	/**
  	 * Mix properties into target object.
  	 *
  	 * @param {Object} to
  	 * @param {Object} from
  	 */
  
  	exports.extend = function (to, from) {
  	  for (var key in from) {
  	    to[key] = from[key]
  	  }
  	  return to
  	}
  
  	/**
  	 * Quick object check - this is primarily used to tell
  	 * Objects from primitive values when we know the value
  	 * is a JSON-compliant type.
  	 *
  	 * @param {*} obj
  	 * @return {Boolean}
  	 */
  
  	exports.isObject = function (obj) {
  	  return obj !== null && typeof obj === 'object'
  	}
  
  	/**
  	 * Strict object type check. Only returns true
  	 * for plain JavaScript objects.
  	 *
  	 * @param {*} obj
  	 * @return {Boolean}
  	 */
  
  	var toString = Object.prototype.toString
  	exports.isPlainObject = function (obj) {
  	  return toString.call(obj) === '[object Object]'
  	}
  
  	/**
  	 * Array type check.
  	 *
  	 * @param {*} obj
  	 * @return {Boolean}
  	 */
  
  	exports.isArray = Array.isArray
  
  	/**
  	 * Define a non-enumerable property
  	 *
  	 * @param {Object} obj
  	 * @param {String} key
  	 * @param {*} val
  	 * @param {Boolean} [enumerable]
  	 */
  
  	exports.define = function (obj, key, val, enumerable) {
  	  Object.defineProperty(obj, key, {
  	    value: val,
  	    enumerable: !!enumerable,
  	    writable: true,
  	    configurable: true
  	  })
  	}
  
  	/**
  	 * Debounce a function so it only gets called after the
  	 * input stops arriving after the given wait period.
  	 *
  	 * @param {Function} func
  	 * @param {Number} wait
  	 * @return {Function} - the debounced function
  	 */
  
  	exports.debounce = function (func, wait) {
  	  var timeout, args, context, timestamp, result
  	  var later = function () {
  	    var last = Date.now() - timestamp
  	    if (last < wait && last >= 0) {
  	      timeout = setTimeout(later, wait - last)
  	    } else {
  	      timeout = null
  	      result = func.apply(context, args)
  	      if (!timeout) context = args = null
  	    }
  	  }
  	  return function () {
  	    context = this
  	    args = arguments
  	    timestamp = Date.now()
  	    if (!timeout) {
  	      timeout = setTimeout(later, wait)
  	    }
  	    return result
  	  }
  	}
  
  	/**
  	 * Manual indexOf because it's slightly faster than
  	 * native.
  	 *
  	 * @param {Array} arr
  	 * @param {*} obj
  	 */
  
  	exports.indexOf = function (arr, obj) {
  	  for (var i = 0, l = arr.length; i < l; i++) {
  	    if (arr[i] === obj) return i
  	  }
  	  return -1
  	}
  
  	/**
  	 * Make a cancellable version of an async callback.
  	 *
  	 * @param {Function} fn
  	 * @return {Function}
  	 */
  
  	exports.cancellable = function (fn) {
  	  var cb = function () {
  	    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}
  	 */
  
  	exports.looseEqual = function (a, b) {
  	  /* eslint-disable eqeqeq */
  	  return a == b || (
  	    exports.isObject(a) && exports.isObject(b)
  	      ? JSON.stringify(a) === JSON.stringify(b)
  	      : false
  	  )
  	  /* eslint-enable eqeqeq */
  	}
  
  
  /***/ },
  /* 3 */
  /***/ function(module, exports) {
  
  	// can we use __proto__?
  	exports.hasProto = '__proto__' in {}
  
  	// Browser environment sniffing
  	var inBrowser = exports.inBrowser =
  	  typeof window !== 'undefined' &&
  	  Object.prototype.toString.call(window) !== '[object Object]'
  
  	exports.isIE9 =
  	  inBrowser &&
  	  navigator.userAgent.toLowerCase().indexOf('msie 9.0') > 0
  
  	exports.isAndroid =
  	  inBrowser &&
  	  navigator.userAgent.toLowerCase().indexOf('android') > 0
  
  	// Transition property/event sniffing
  	if (inBrowser && !exports.isIE9) {
  	  var isWebkitTrans =
  	    window.ontransitionend === undefined &&
  	    window.onwebkittransitionend !== undefined
  	  var isWebkitAnim =
  	    window.onanimationend === undefined &&
  	    window.onwebkitanimationend !== undefined
  	  exports.transitionProp = isWebkitTrans
  	    ? 'WebkitTransition'
  	    : 'transition'
  	  exports.transitionEndEvent = isWebkitTrans
  	    ? 'webkitTransitionEnd'
  	    : 'transitionend'
  	  exports.animationProp = isWebkitAnim
  	    ? 'WebkitAnimation'
  	    : 'animation'
  	  exports.animationEndEvent = isWebkitAnim
  	    ? 'webkitAnimationEnd'
  	    : 'animationend'
  	}
  
  	/**
  	 * Defer a task to execute it asynchronously. Ideally this
  	 * should be executed as a microtask, so we leverage
  	 * MutationObserver if it's available, and fallback to
  	 * setTimeout(0).
  	 *
  	 * @param {Function} cb
  	 * @param {Object} ctx
  	 */
  
  	exports.nextTick = (function () {
  	  var callbacks = []
  	  var pending = false
  	  var timerFunc
  	  function 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') {
  	    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 {
  	    timerFunc = setTimeout
  	  }
  	  return function (cb, ctx) {
  	    var func = ctx
  	      ? function () { cb.call(ctx) }
  	      : cb
  	    callbacks.push(func)
  	    if (pending) return
  	    pending = true
  	    timerFunc(nextTickHandler, 0)
  	  }
  	})()
  
  
  /***/ },
  /* 4 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  
  	/**
  	 * Query an element selector if it's not an element already.
  	 *
  	 * @param {String|Element} el
  	 * @return {Element}
  	 */
  
  	exports.query = function (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 byy doing the
  	 * contains() check on the node's parentNode instead of
  	 * the node itself.
  	 *
  	 * @param {Node} node
  	 * @return {Boolean}
  	 */
  
  	exports.inDoc = function (node) {
  	  var doc = document.documentElement
  	  var parent = node && node.parentNode
  	  return doc === node ||
  	    doc === parent ||
  	    !!(parent && parent.nodeType === 1 && (doc.contains(parent)))
  	}
  
  	/**
  	 * Extract an attribute from a node.
  	 *
  	 * @param {Node} node
  	 * @param {String} attr
  	 */
  
  	exports.attr = function (node, attr) {
  	  attr = config.prefix + attr
  	  var val = node.getAttribute(attr)
  	  if (val !== null) {
  	    node.removeAttribute(attr)
  	  }
  	  return val
  	}
  
  	/**
  	 * Insert el before target
  	 *
  	 * @param {Element} el
  	 * @param {Element} target
  	 */
  
  	exports.before = function (el, target) {
  	  target.parentNode.insertBefore(el, target)
  	}
  
  	/**
  	 * Insert el after target
  	 *
  	 * @param {Element} el
  	 * @param {Element} target
  	 */
  
  	exports.after = function (el, target) {
  	  if (target.nextSibling) {
  	    exports.before(el, target.nextSibling)
  	  } else {
  	    target.parentNode.appendChild(el)
  	  }
  	}
  
  	/**
  	 * Remove el from DOM
  	 *
  	 * @param {Element} el
  	 */
  
  	exports.remove = function (el) {
  	  el.parentNode.removeChild(el)
  	}
  
  	/**
  	 * Prepend el to target
  	 *
  	 * @param {Element} el
  	 * @param {Element} target
  	 */
  
  	exports.prepend = function (el, target) {
  	  if (target.firstChild) {
  	    exports.before(el, target.firstChild)
  	  } else {
  	    target.appendChild(el)
  	  }
  	}
  
  	/**
  	 * Replace target with el
  	 *
  	 * @param {Element} target
  	 * @param {Element} el
  	 */
  
  	exports.replace = function (target, el) {
  	  var parent = target.parentNode
  	  if (parent) {
  	    parent.replaceChild(el, target)
  	  }
  	}
  
  	/**
  	 * Add event listener shorthand.
  	 *
  	 * @param {Element} el
  	 * @param {String} event
  	 * @param {Function} cb
  	 */
  
  	exports.on = function (el, event, cb) {
  	  el.addEventListener(event, cb)
  	}
  
  	/**
  	 * Remove event listener shorthand.
  	 *
  	 * @param {Element} el
  	 * @param {String} event
  	 * @param {Function} cb
  	 */
  
  	exports.off = function (el, event, cb) {
  	  el.removeEventListener(event, cb)
  	}
  
  	/**
  	 * Add class with compatibility for IE & SVG
  	 *
  	 * @param {Element} el
  	 * @param {Strong} cls
  	 */
  
  	exports.addClass = function (el, cls) {
  	  if (el.classList) {
  	    el.classList.add(cls)
  	  } else {
  	    var cur = ' ' + (el.getAttribute('class') || '') + ' '
  	    if (cur.indexOf(' ' + cls + ' ') < 0) {
  	      el.setAttribute('class', (cur + cls).trim())
  	    }
  	  }
  	}
  
  	/**
  	 * Remove class with compatibility for IE & SVG
  	 *
  	 * @param {Element} el
  	 * @param {Strong} cls
  	 */
  
  	exports.removeClass = function (el, cls) {
  	  if (el.classList) {
  	    el.classList.remove(cls)
  	  } else {
  	    var cur = ' ' + (el.getAttribute('class') || '') + ' '
  	    var tar = ' ' + cls + ' '
  	    while (cur.indexOf(tar) >= 0) {
  	      cur = cur.replace(tar, ' ')
  	    }
  	    el.setAttribute('class', cur.trim())
  	  }
  	}
  
  	/**
  	 * Extract raw content inside an element into a temporary
  	 * container div
  	 *
  	 * @param {Element} el
  	 * @param {Boolean} asFragment
  	 * @return {Element}
  	 */
  
  	exports.extractContent = function (el, asFragment) {
  	  var child
  	  var rawContent
  	  /* istanbul ignore if */
  	  if (
  	    exports.isTemplate(el) &&
  	    el.content instanceof DocumentFragment
  	  ) {
  	    el = el.content
  	  }
  	  if (el.hasChildNodes()) {
  	    exports.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 textNodes inside a parent.
  	 *
  	 * @param {Node} node
  	 */
  
  	exports.trimNode = function (node) {
  	  trim(node, node.firstChild)
  	  trim(node, node.lastChild)
  	}
  
  	function trim (parent, node) {
  	  if (node && node.nodeType === 3 && !node.data.trim()) {
  	    parent.removeChild(node)
  	  }
  	}
  
  	/**
  	 * 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
  	 */
  
  	exports.isTemplate = function (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
  	 * - component
  	 * - repeat
  	 *
  	 * @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}
  	 */
  
  	exports.createAnchor = function (content, persist) {
  	  return config.debug
  	    ? document.createComment(content)
  	    : document.createTextNode(persist ? ' ' : '')
  	}
  
  
  /***/ },
  /* 5 */
  /***/ function(module, exports) {
  
  	module.exports = {
  
  	  /**
  	   * The prefix to look for when parsing directives.
  	   *
  	   * @type {String}
  	   */
  
  	  prefix: 'v-',
  
  	  /**
  	   * Whether to print debug messages.
  	   * Also enables stack trace for warnings.
  	   *
  	   * @type {Boolean}
  	   */
  
  	  debug: false,
  
  	  /**
  	   * Strict mode.
  	   * Disables asset lookup in the view parent chain.
  	   */
  
  	  strict: false,
  
  	  /**
  	   * Whether to suppress warnings.
  	   *
  	   * @type {Boolean}
  	   */
  
  	  silent: false,
  
  	  /**
  	   * Whether allow observer to alter data objects'
  	   * __proto__.
  	   *
  	   * @type {Boolean}
  	   */
  
  	  proto: true,
  
  	  /**
  	   * Whether to parse mustache tags in templates.
  	   *
  	   * @type {Boolean}
  	   */
  
  	  interpolate: true,
  
  	  /**
  	   * Whether to use async rendering.
  	   */
  
  	  async: true,
  
  	  /**
  	   * Whether to warn against errors caught when evaluating
  	   * expressions.
  	   */
  
  	  warnExpressionErrors: true,
  
  	  /**
  	   * Internal flag to indicate the delimiters have been
  	   * changed.
  	   *
  	   * @type {Boolean}
  	   */
  
  	  _delimitersChanged: true,
  
  	  /**
  	   * List of asset types that a component can own.
  	   *
  	   * @type {Array}
  	   */
  
  	  _assetTypes: [
  	    '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
  
  	}
  
  	/**
  	 * Interpolation delimiters.
  	 * We need to mark the changed flag so that the text parser
  	 * knows it needs to recompile the regex.
  	 *
  	 * @type {Array<String>}
  	 */
  
  	var delimiters = ['{{', '}}']
  	Object.defineProperty(module.exports, 'delimiters', {
  	  get: function () {
  	    return delimiters
  	  },
  	  set: function (val) {
  	    delimiters = val
  	    this._delimitersChanged = true
  	  }
  	})
  
  
  /***/ },
  /* 6 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  	var extend = _.extend
  
  	/**
  	 * Option overwriting strategies are functions that handle
  	 * how to merge a parent option value and a child option
  	 * value into the final value.
  	 *
  	 * All strategy functions follow the same signature:
  	 *
  	 * @param {*} parentVal
  	 * @param {*} childVal
  	 * @param {Vue} [vm]
  	 */
  
  	var strats = Object.create(null)
  
  	/**
  	 * Helper that recursively merges two data objects together.
  	 */
  
  	function mergeData (to, from) {
  	  var key, toVal, fromVal
  	  for (key in from) {
  	    toVal = to[key]
  	    fromVal = from[key]
  	    if (!to.hasOwnProperty(key)) {
  	      to.$add(key, fromVal)
  	    } else if (_.isObject(toVal) && _.isObject(fromVal)) {
  	      mergeData(toVal, fromVal)
  	    }
  	  }
  	  return to
  	}
  
  	/**
  	 * Data
  	 */
  
  	strats.data = function (parentVal, childVal, vm) {
  	  if (!vm) {
  	    // in a Vue.extend merge, both should be functions
  	    if (!childVal) {
  	      return parentVal
  	    }
  	    if (typeof childVal !== 'function') {
  	      ("development") !== 'production' && _.warn(
  	        'The "data" option should be a function ' +
  	        'that returns a per-instance value in component ' +
  	        'definitions.'
  	      )
  	      return parentVal
  	    }
  	    if (!parentVal) {
  	      return childVal
  	    }
  	    // when parentVal & childVal are both present,
  	    // we need to return a function that returns the
  	    // merged result of both functions... no need to
  	    // check if parentVal is a function here because
  	    // it has to be a function to pass previous merges.
  	    return function mergedDataFn () {
  	      return mergeData(
  	        childVal.call(this),
  	        parentVal.call(this)
  	      )
  	    }
  	  } else 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.'
  	    )
  	    return
  	  }
  	  var ret = childVal || parentVal
  	  // invoke the element factory if this is instance merge
  	  return vm && typeof ret === 'function'
  	    ? ret.call(vm)
  	    : ret
  	}
  
  	/**
  	 * Hooks and param attributes are merged as arrays.
  	 */
  
  	strats.created =
  	strats.ready =
  	strats.attached =
  	strats.detached =
  	strats.beforeCompile =
  	strats.compiled =
  	strats.beforeDestroy =
  	strats.destroyed =
  	strats.props = function (parentVal, childVal) {
  	  return childVal
  	    ? parentVal
  	      ? parentVal.concat(childVal)
  	      : _.isArray(childVal)
  	        ? childVal
  	        : [childVal]
  	    : parentVal
  	}
  
  	/**
  	 * 0.11 deprecation warning
  	 */
  
  	strats.paramAttributes = function () {
  	  /* istanbul ignore next */
  	  ("development") !== 'production' && _.warn(
  	    '"paramAttributes" option has been deprecated in 0.12. ' +
  	    'Use "props" instead.'
  	  )
  	}
  
  	/**
  	 * 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)
  	  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.methods =
  	strats.computed = function (parentVal, childVal) {
  	  if (!childVal) return parentVal
  	  if (!parentVal) return childVal
  	  var ret = Object.create(parentVal)
  	  extend(ret, childVal)
  	  return ret
  	}
  
  	/**
  	 * Default strategy.
  	 */
  
  	var defaultStrat = function (parentVal, childVal) {
  	  return childVal === undefined
  	    ? parentVal
  	    : childVal
  	}
  
  	/**
  	 * Make sure component options get converted to actual
  	 * constructors.
  	 *
  	 * @param {Object} options
  	 */
  
  	function guardComponents (options) {
  	  if (options.components) {
  	    var components = options.components =
  	      guardArrayAssets(options.components)
  	    var def
  	    var ids = Object.keys(components)
  	    for (var i = 0, l = ids.length; i < l; i++) {
  	      var key = ids[i]
  	      if (_.commonTagRE.test(key)) {
  	        ("development") !== 'production' && _.warn(
  	          'Do not use built-in HTML elements as component ' +
  	          'id: ' + key
  	        )
  	        continue
  	      }
  	      def = components[key]
  	      if (_.isPlainObject(def)) {
  	        def.id = def.id || key
  	        components[key] = def._Ctor || (def._Ctor = _.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
  	  if (_.isPlainObject(props)) {
  	    options.props = Object.keys(props).map(function (key) {
  	      var val = props[key]
  	      if (!_.isPlainObject(val)) {
  	        val = { type: val }
  	      }
  	      val.name = key
  	      return val
  	    })
  	  } else if (_.isArray(props)) {
  	    options.props = props.map(function (prop) {
  	      return typeof prop === 'string'
  	        ? { name: prop }
  	        : prop
  	    })
  	  }
  	}
  
  	/**
  	 * 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 = asset.id || (asset.options && asset.options.id)
  	      if (!id) {
  	        ("development") !== 'production' && _.warn(
  	          'Array-syntax assets must provide an 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.
  	 */
  
  	exports.mergeOptions = function merge (parent, child, vm) {
  	  guardComponents(child)
  	  guardProps(child)
  	  var options = {}
  	  var key
  	  if (child.mixins) {
  	    for (var i = 0, l = child.mixins.length; i < l; i++) {
  	      parent = merge(parent, child.mixins[i], vm)
  	    }
  	  }
  	  for (key in parent) {
  	    mergeField(key)
  	  }
  	  for (key in child) {
  	    if (!(parent.hasOwnProperty(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
  	 * @return {Object|Function}
  	 */
  
  	exports.resolveAsset = function resolve (options, type, id) {
  	  var camelizedId = _.camelize(id)
  	  var pascalizedId = camelizedId.charAt(0).toUpperCase() + camelizedId.slice(1)
  	  var assets = options[type]
  	  var asset = assets[id] || assets[camelizedId] || assets[pascalizedId]
  	  while (
  	    !asset &&
  	    options._parent &&
  	    (!config.strict || options._repeat)
  	  ) {
  	    options = (options._context || options._parent).$options
  	    assets = options[type]
  	    asset = assets[id] || assets[camelizedId] || assets[pascalizedId]
  	  }
  	  return asset
  	}
  
  
  /***/ },
  /* 7 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	/**
  	 * Check if an element is a component, if yes return its
  	 * component id.
  	 *
  	 * @param {Element} el
  	 * @param {Object} options
  	 * @return {String|undefined}
  	 */
  
  	exports.commonTagRE = /^(div|p|span|img|a|br|ul|ol|li|h1|h2|h3|h4|h5|code|pre)$/
  	exports.checkComponent = function (el, options) {
  	  var tag = el.tagName.toLowerCase()
  	  if (tag === 'component') {
  	    // dynamic syntax
  	    var exp = el.getAttribute('is')
  	    el.removeAttribute('is')
  	    return exp
  	  } else if (
  	    !exports.commonTagRE.test(tag) &&
  	    _.resolveAsset(options, 'components', tag)
  	  ) {
  	    return tag
  	  /* eslint-disable no-cond-assign */
  	  } else if (tag = _.attr(el, 'component')) {
  	  /* eslint-enable no-cond-assign */
  	    return tag
  	  }
  	}
  
  	/**
  	 * Set a prop's initial value on a vm and its data object.
  	 * The vm may have inherit:true so we need to make sure
  	 * we don't accidentally overwrite parent value.
  	 *
  	 * @param {Vue} vm
  	 * @param {Object} prop
  	 * @param {*} value
  	 */
  
  	exports.initProp = function (vm, prop, value) {
  	  if (exports.assertProp(prop, value)) {
  	    var key = prop.path
  	    if (key in vm) {
  	      _.define(vm, key, value, true)
  	    } else {
  	      vm[key] = value
  	    }
  	    vm._data[key] = value
  	  }
  	}
  
  	/**
  	 * Assert whether a prop is valid.
  	 *
  	 * @param {Object} prop
  	 * @param {*} value
  	 */
  
  	exports.assertProp = function (prop, value) {
  	  // if a prop is not provided and is not required,
  	  // skip the check.
  	  if (prop.raw === null && !prop.required) {
  	    return true
  	  }
  	  var options = prop.options
  	  var type = options.type
  	  var valid = true
  	  var expectedType
  	  if (type) {
  	    if (type === String) {
  	      expectedType = 'string'
  	      valid = typeof value === expectedType
  	    } else if (type === Number) {
  	      expectedType = 'number'
  	      valid = typeof value === 'number'
  	    } else if (type === Boolean) {
  	      expectedType = 'boolean'
  	      valid = typeof value === 'boolean'
  	    } else if (type === Function) {
  	      expectedType = 'function'
  	      valid = typeof value === 'function'
  	    } else if (type === Object) {
  	      expectedType = 'object'
  	      valid = _.isPlainObject(value)
  	    } else if (type === Array) {
  	      expectedType = 'array'
  	      valid = _.isArray(value)
  	    } else {
  	      valid = value instanceof type
  	    }
  	  }
  	  if (!valid) {
  	    ("development") !== 'production' && _.warn(
  	      'Invalid prop: type check failed for ' +
  	      prop.path + '="' + prop.raw + '".' +
  	      ' Expected ' + formatType(expectedType) +
  	      ', got ' + formatValue(value) + '.'
  	    )
  	    return false
  	  }
  	  var validator = options.validator
  	  if (validator) {
  	    if (!validator.call(null, value)) {
  	      ("development") !== 'production' && _.warn(
  	        'Invalid prop: custom validator check failed for ' +
  	        prop.path + '="' + prop.raw + '"'
  	      )
  	      return false
  	    }
  	  }
  	  return true
  	}
  
  	function formatType (val) {
  	  return val
  	    ? val.charAt(0).toUpperCase() + val.slice(1)
  	    : 'custom type'
  	}
  
  	function formatValue (val) {
  	  return Object.prototype.toString.call(val).slice(8, -1)
  	}
  
  
  /***/ },
  /* 8 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * Enable debug utilities.
  	 */
  
  	if (true) {
  
  	  var config = __webpack_require__(5)
  	  var hasConsole = typeof console !== 'undefined'
  
  	  /**
  	   * Log a message.
  	   *
  	   * @param {String} msg
  	   */
  
  	  exports.log = function (msg) {
  	    if (hasConsole && config.debug) {
  	      console.log('[Vue info]: ' + msg)
  	    }
  	  }
  
  	  /**
  	   * We've got a problem here.
  	   *
  	   * @param {String} msg
  	   */
  
  	  exports.warn = function (msg, e) {
  	    if (hasConsole && (!config.silent || config.debug)) {
  	      console.warn('[Vue warn]: ' + msg)
  	      /* istanbul ignore if */
  	      if (config.debug) {
  	        console.warn((e || new Error('Warning Stack Trace')).stack)
  	      }
  	    }
  	  }
  
  	  /**
  	   * Assert asset exists
  	   */
  
  	  exports.assertAsset = function (val, type, id) {
  	    /* istanbul ignore if */
  	    if (type === 'directive') {
  	      if (id === 'with') {
  	        exports.warn(
  	          'v-with has been deprecated in ^0.12.0. ' +
  	          'Use props instead.'
  	        )
  	        return
  	      }
  	      if (id === 'events') {
  	        exports.warn(
  	          'v-events has been deprecated in ^0.12.0. ' +
  	          'Pass down methods as callback props instead.'
  	        )
  	        return
  	      }
  	    }
  	    if (!val) {
  	      exports.warn('Failed to resolve ' + type + ': ' + id)
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 9 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  
  	/**
  	 * Expose useful internals
  	 */
  
  	exports.util = _
  	exports.config = config
  	exports.nextTick = _.nextTick
  	exports.compiler = __webpack_require__(10)
  
  	exports.parsers = {
  	  path: __webpack_require__(20),
  	  text: __webpack_require__(13),
  	  template: __webpack_require__(22),
  	  directive: __webpack_require__(15),
  	  expression: __webpack_require__(19)
  	}
  
  	/**
  	 * Each instance constructor, including Vue, has a unique
  	 * cid. This enables us to create wrapped "child
  	 * constructors" for prototypal inheritance and cache them.
  	 */
  
  	exports.cid = 0
  	var cid = 1
  
  	/**
  	 * Class inheritance
  	 *
  	 * @param {Object} extendOptions
  	 */
  
  	exports.extend = function (extendOptions) {
  	  extendOptions = extendOptions || {}
  	  var Super = this
  	  var Sub = createClass(
  	    extendOptions.name ||
  	    Super.options.name ||
  	    'VueComponent'
  	  )
  	  Sub.prototype = Object.create(Super.prototype)
  	  Sub.prototype.constructor = Sub
  	  Sub.cid = cid++
  	  Sub.options = _.mergeOptions(
  	    Super.options,
  	    extendOptions
  	  )
  	  Sub['super'] = Super
  	  // allow further extension
  	  Sub.extend = Super.extend
  	  // create asset registers, so extended classes
  	  // can have their private assets too.
  	  config._assetTypes.forEach(function (type) {
  	    Sub[type] = Super[type]
  	  })
  	  return Sub
  	}
  
  	/**
  	 * A function that returns a sub-class constructor with the
  	 * given name. This gives us much nicer output when
  	 * logging instances in the console.
  	 *
  	 * @param {String} name
  	 * @return {Function}
  	 */
  
  	function createClass (name) {
  	  return new Function(
  	    'return function ' + _.classify(name) +
  	    ' (options) { this._init(options) }'
  	  )()
  	}
  
  	/**
  	 * Plugin system
  	 *
  	 * @param {Object} plugin
  	 */
  
  	exports.use = function (plugin) {
  	  // additional parameters
  	  var args = _.toArray(arguments, 1)
  	  args.unshift(this)
  	  if (typeof plugin.install === 'function') {
  	    plugin.install.apply(plugin, args)
  	  } else {
  	    plugin.apply(null, args)
  	  }
  	  return this
  	}
  
  	/**
  	 * Create asset registration methods with the following
  	 * signature:
  	 *
  	 * @param {String} id
  	 * @param {*} definition
  	 */
  
  	config._assetTypes.forEach(function (type) {
  	  exports[type] = function (id, definition) {
  	    if (!definition) {
  	      return this.options[type + 's'][id]
  	    } else {
  	      if (
  	        type === 'component' &&
  	        _.isPlainObject(definition)
  	      ) {
  	        definition.name = id
  	        definition = _.Vue.extend(definition)
  	      }
  	      this.options[type + 's'][id] = definition
  	    }
  	  }
  	})
  
  
  /***/ },
  /* 10 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	_.extend(exports, __webpack_require__(11))
  	_.extend(exports, __webpack_require__(24))
  
  
  /***/ },
  /* 11 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var compileProps = __webpack_require__(12)
  	var config = __webpack_require__(5)
  	var textParser = __webpack_require__(13)
  	var dirParser = __webpack_require__(15)
  	var templateParser = __webpack_require__(22)
  	var resolveAsset = _.resolveAsset
  	var componentDef = __webpack_require__(23)
  
  	// terminal directives
  	var terminalDirectives = [
  	  'repeat',
  	  'if'
  	]
  
  	/**
  	 * 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}
  	 */
  
  	exports.compile = function (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) &&
  	    el.tagName !== 'SCRIPT' &&
  	    el.hasChildNodes()
  	      ? compileNodeList(el.childNodes, options)
  	      : null
  
  	  /**
  	   * A composite linker function to be called on a already
  	   * compiled piece of DOM, which instantiates all directive
  	   * instances.
  	   *
  	   * @param {Vue} vm
  	   * @param {Element|DocumentFragment} el
  	   * @param {Vue} [host] - host vm of transcluded content
  	   * @return {Function|undefined}
  	   */
  
  	  return function compositeLinkFn (vm, el, host) {
  	    // cache childNodes before linking parent, fix #657
  	    var childNodes = _.toArray(el.childNodes)
  	    // link
  	    var dirs = linkAndCapture(function () {
  	      if (nodeLinkFn) nodeLinkFn(vm, el, host)
  	      if (childLinkFn) childLinkFn(vm, childNodes, host)
  	    }, 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) {
  	  var originalDirCount = vm._directives.length
  	  linker()
  	  return vm._directives.slice(originalDirCount)
  	}
  
  	/**
  	 * 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) {
  	  return function unlink (destroying) {
  	    teardownDirs(vm, dirs, destroying)
  	    if (context && contextDirs) {
  	      teardownDirs(context, contextDirs)
  	    }
  	  }
  	}
  
  	/**
  	 * 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 (!destroying) {
  	      vm._directives.$remove(dirs[i])
  	    }
  	  }
  	}
  
  	/**
  	 * Compile link props on an instance.
  	 *
  	 * @param {Vue} vm
  	 * @param {Element} el
  	 * @param {Object} options
  	 * @return {Function}
  	 */
  
  	exports.compileAndLinkProps = function (vm, el, props) {
  	  var propsLinkFn = compileProps(el, props)
  	  var propDirs = linkAndCapture(function () {
  	    propsLinkFn(vm, null)
  	  }, 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 {Vue} vm
  	 * @param {Element} el
  	 * @param {Object} options
  	 * @return {Function}
  	 */
  
  	exports.compileRoot = function (el, options) {
  	  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) {
  	        contextLinkFn = compileDirectives(containerAttrs, options)
  	      }
  	      if (replacerAttrs) {
  	        // 3. replacer attributes
  	        replacerLinkFn = compileDirectives(replacerAttrs, options)
  	      }
  	    } else {
  	      // non-component, just compile as a normal element.
  	      replacerLinkFn = compileDirectives(el.attributes, options)
  	    }
  	  }
  
  	  return function rootLinkFn (vm, el) {
  	    // link context scope dirs
  	    var context = vm._context
  	    var contextDirs
  	    if (context && contextLinkFn) {
  	      contextDirs = linkAndCapture(function () {
  	        contextLinkFn(context, el)
  	      }, 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 && node.tagName !== 'SCRIPT') {
  	    return compileElement(node, options)
  	  } else if (type === 3 && config.interpolate && 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 a v-attr directive for value.
  	  if (el.tagName === 'TEXTAREA') {
  	    if (textParser.parse(el.value)) {
  	      el.setAttribute('value', el.value)
  	    }
  	  }
  	  var linkFn
  	  var hasAttrs = el.hasAttributes()
  	  // check terminal directives (repeat & if)
  	  if (hasAttrs) {
  	    linkFn = checkTerminalDirectives(el, 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(el.attributes, options)
  	  }
  	  return linkFn
  	}
  
  	/**
  	 * Compile a textNode and return a nodeLinkFn.
  	 *
  	 * @param {TextNode} node
  	 * @param {Object} options
  	 * @return {Function|null} textNodeLinkFn
  	 */
  
  	function compileTextNode (node, options) {
  	  var tokens = textParser.parse(node.data)
  	  if (!tokens) {
  	    return null
  	  }
  	  var frag = document.createDocumentFragment()
  	  var el, token
  	  for (var i = 0, l = tokens.length; i < l; i++) {
  	    token = tokens[i]
  	    el = token.tag
  	      ? processTextToken(token, options)
  	      : document.createTextNode(token.value)
  	    frag.appendChild(el)
  	  }
  	  return makeTextNodeLinkFn(tokens, frag, options)
  	}
  
  	/**
  	 * 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) {
  	    token.type = type
  	    token.def = resolveAsset(options, 'directives', type)
  	    token.descriptor = dirParser.parse(token.value)[0]
  	  }
  	  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) {
  	    var fragClone = frag.cloneNode(true)
  	    var childNodes = _.toArray(fragClone.childNodes)
  	    var token, value, node
  	    for (var i = 0, l = tokens.length; i < l; i++) {
  	      token = tokens[i]
  	      value = token.value
  	      if (token.tag) {
  	        node = childNodes[i]
  	        if (token.oneTime) {
  	          value = vm.$eval(value)
  	          if (token.html) {
  	            _.replace(node, templateParser.parse(value, true))
  	          } else {
  	            node.data = value
  	          }
  	        } else {
  	          vm._bindDir(token.type, node,
  	                      token.descriptor, token.def)
  	        }
  	      }
  	    }
  	    _.replace(el, fragClone)
  	  }
  	}
  
  	/**
  	 * 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) {
  	    var node, nodeLinkFn, childrenLinkFn
  	    for (var i = 0, n = 0, l = linkFns.length; i < l; n++) {
  	      node = nodes[n]
  	      nodeLinkFn = linkFns[i++]
  	      childrenLinkFn = linkFns[i++]
  	      // cache childNodes before linking parent, fix #657
  	      var childNodes = _.toArray(node.childNodes)
  	      if (nodeLinkFn) {
  	        nodeLinkFn(vm, node, host)
  	      }
  	      if (childrenLinkFn) {
  	        childrenLinkFn(vm, childNodes, host)
  	      }
  	    }
  	  }
  	}
  
  	/**
  	 * 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
  	 * @param {Boolean} hasAttrs
  	 * @return {Function|undefined}
  	 */
  
  	function checkComponent (el, options, hasAttrs) {
  	  var componentId = _.checkComponent(el, options, hasAttrs)
  	  if (componentId) {
  	    var componentLinkFn = function (vm, el, host) {
  	      vm._bindDir('component', el, {
  	        expression: componentId
  	      }, componentDef, host)
  	    }
  	    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 {Object} options
  	 * @return {Function} terminalLinkFn
  	 */
  
  	function checkTerminalDirectives (el, options) {
  	  if (_.attr(el, 'pre') !== null) {
  	    return skip
  	  }
  	  var value, dirName
  	  for (var i = 0, l = terminalDirectives.length; i < l; i++) {
  	    dirName = terminalDirectives[i]
  	    if ((value = _.attr(el, dirName)) !== null) {
  	      return makeTerminalNodeLinkFn(el, dirName, value, options)
  	    }
  	  }
  	}
  
  	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]
  	 * @return {Function} terminalLinkFn
  	 */
  
  	function makeTerminalNodeLinkFn (el, dirName, value, options, def) {
  	  var descriptor = dirParser.parse(value)[0]
  	  // no need to call resolveAsset since terminal directives
  	  // are always internal
  	  def = def || options.directives[dirName]
  	  var fn = function terminalNodeLinkFn (vm, el, host) {
  	    vm._bindDir(dirName, el, descriptor, def, host)
  	  }
  	  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, dir, dirName, dirDef
  	  while (i--) {
  	    attr = attrs[i]
  	    name = attr.name
  	    value = attr.value
  	    if (name.indexOf(config.prefix) === 0) {
  	      dirName = name.slice(config.prefix.length)
  	      dirDef = resolveAsset(options, 'directives', dirName)
  	      if (true) {
  	        _.assertAsset(dirDef, 'directive', dirName)
  	      }
  	      if (dirDef) {
  	        dirs.push({
  	          name: dirName,
  	          descriptors: dirParser.parse(value),
  	          def: dirDef
  	        })
  	      }
  	    } else if (config.interpolate) {
  	      dir = collectAttrDirective(name, value, options)
  	      if (dir) {
  	        dirs.push(dir)
  	      }
  	    }
  	  }
  	  // sort by priority, LOW to HIGH
  	  if (dirs.length) {
  	    dirs.sort(directiveComparator)
  	    return makeNodeLinkFn(dirs)
  	  }
  	}
  
  	/**
  	 * 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) {
  	    // reverse apply because it's sorted low to high
  	    var i = directives.length
  	    var dir, j, k
  	    while (i--) {
  	      dir = directives[i]
  	      if (dir._link) {
  	        // custom link fn
  	        dir._link(vm, el)
  	      } else {
  	        k = dir.descriptors.length
  	        for (j = 0; j < k; j++) {
  	          vm._bindDir(dir.name, el,
  	            dir.descriptors[j], dir.def, host)
  	        }
  	      }
  	    }
  	  }
  	}
  
  	/**
  	 * Check an attribute for potential dynamic bindings,
  	 * and return a directive object.
  	 *
  	 * Special case: class interpolations are translated into
  	 * v-class instead v-attr, so that it can work with user
  	 * provided v-class bindings.
  	 *
  	 * @param {String} name
  	 * @param {String} value
  	 * @param {Object} options
  	 * @return {Object}
  	 */
  
  	function collectAttrDirective (name, value, options) {
  	  var tokens = textParser.parse(value)
  	  var isClass = name === 'class'
  	  if (tokens) {
  	    var dirName = isClass ? 'class' : 'attr'
  	    var def = options.directives[dirName]
  	    var i = tokens.length
  	    var allOneTime = true
  	    while (i--) {
  	      var token = tokens[i]
  	      if (token.tag && !token.oneTime) {
  	        allOneTime = false
  	      }
  	    }
  	    return {
  	      def: def,
  	      _link: allOneTime
  	        ? function (vm, el) {
  	            el.setAttribute(name, vm.$interpolate(value))
  	          }
  	        : function (vm, el) {
  	            var exp = textParser.tokensToExp(tokens, vm)
  	            var desc = isClass
  	              ? dirParser.parse(exp)[0]
  	              : dirParser.parse(name + ':' + exp)[0]
  	            if (isClass) {
  	              desc._rawClass = value
  	            }
  	            vm._bindDir(dirName, el, desc, def)
  	          }
  	    }
  	  }
  	}
  
  	/**
  	 * Directive priority sort comparator
  	 *
  	 * @param {Object} a
  	 * @param {Object} b
  	 */
  
  	function directiveComparator (a, b) {
  	  a = a.def.priority || 0
  	  b = b.def.priority || 0
  	  return a > b ? 1 : -1
  	}
  
  
  /***/ },
  /* 12 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var textParser = __webpack_require__(13)
  	var propDef = __webpack_require__(16)
  	var propBindingModes = __webpack_require__(5)._propBindingModes
  
  	// regexes
  	var identRE = __webpack_require__(20).identRE
  	var dataAttrRE = /^data-/
  	var settablePathRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\[[^\[\]]+\])*$/
  	var literalValueRE = /^(true|false)$|^\d.*/
  
  	/**
  	 * Compile param attributes on a root element and return
  	 * a props link function.
  	 *
  	 * @param {Element|DocumentFragment} el
  	 * @param {Array} propOptions
  	 * @return {Function} propsLinkFn
  	 */
  
  	module.exports = function compileProps (el, propOptions) {
  	  var props = []
  	  var i = propOptions.length
  	  var options, name, attr, value, path, prop, literal, single
  	  while (i--) {
  	    options = propOptions[i]
  	    name = options.name
  	    // 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.replace(dataAttrRE, ''))
  	    if (!identRE.test(path)) {
  	      ("development") !== 'production' && _.warn(
  	        'Invalid prop key: "' + name + '". Prop keys ' +
  	        'must be valid identifiers.'
  	      )
  	      continue
  	    }
  	    attr = _.hyphenate(name)
  	    value = el.getAttribute(attr)
  	    if (value === null) {
  	      attr = 'data-' + attr
  	      value = el.getAttribute(attr)
  	    }
  	    // create a prop descriptor
  	    prop = {
  	      name: name,
  	      raw: value,
  	      path: path,
  	      options: options,
  	      mode: propBindingModes.ONE_WAY
  	    }
  	    if (value !== null) {
  	      // important so that this doesn't get compiled
  	      // again as a normal attribute binding
  	      el.removeAttribute(attr)
  	      var tokens = textParser.parse(value)
  	      if (tokens) {
  	        prop.dynamic = true
  	        prop.parentPath = textParser.tokensToExp(tokens)
  	        // check prop binding type.
  	        single = tokens.length === 1
  	        literal = literalValueRE.test(prop.parentPath)
  	        // one time: {{* prop}}
  	        if (literal || (single && tokens[0].oneTime)) {
  	          prop.mode = propBindingModes.ONE_TIME
  	        } else if (
  	          !literal &&
  	          (single && tokens[0].twoWay)
  	        ) {
  	          if (settablePathRE.test(prop.parentPath)) {
  	            prop.mode = propBindingModes.TWO_WAY
  	          } else {
  	            ("development") !== 'production' && _.warn(
  	              'Cannot bind two-way prop with non-settable ' +
  	              'parent path: ' + prop.parentPath
  	            )
  	          }
  	        }
  	        if (
  	          ("development") !== 'production' &&
  	          options.twoWay &&
  	          prop.mode !== propBindingModes.TWO_WAY
  	        ) {
  	          _.warn(
  	            'Prop "' + name + '" expects a two-way binding type.'
  	          )
  	        }
  	      }
  	    } else if (options && options.required) {
  	      ("development") !== 'production' && _.warn(
  	        'Missing required prop: ' + name
  	      )
  	    }
  	    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, el) {
  	    // store resolved props info
  	    vm._props = {}
  	    var i = props.length
  	    var prop, path, options, value
  	    while (i--) {
  	      prop = props[i]
  	      path = prop.path
  	      vm._props[path] = prop
  	      options = prop.options
  	      if (prop.raw === null) {
  	        // initialize absent prop
  	        _.initProp(vm, prop, getDefault(options))
  	      } else if (prop.dynamic) {
  	        // dynamic prop
  	        if (vm._context) {
  	          if (prop.mode === propBindingModes.ONE_TIME) {
  	            // one time binding
  	            value = vm._context.$get(prop.parentPath)
  	            _.initProp(vm, prop, value)
  	          } else {
  	            // dynamic binding
  	            vm._bindDir('prop', el, prop, propDef)
  	          }
  	        } else {
  	          ("development") !== 'production' && _.warn(
  	            'Cannot bind dynamic prop on a root instance' +
  	            ' with no parent: ' + prop.name + '="' +
  	            prop.raw + '"'
  	          )
  	        }
  	      } else {
  	        // literal, cast it and just set once
  	        var raw = prop.raw
  	        value = options.type === Boolean && raw === ''
  	          ? true
  	          // do not cast emptry string.
  	          // _.toNumber casts empty string to 0.
  	          : raw.trim()
  	            ? _.toBoolean(_.toNumber(raw))
  	            : raw
  	        _.initProp(vm, prop, value)
  	      }
  	    }
  	  }
  	}
  
  	/**
  	 * Get the default value of a prop.
  	 *
  	 * @param {Object} options
  	 * @return {*}
  	 */
  
  	function getDefault (options) {
  	  // no default, return undefined
  	  if (!options.hasOwnProperty('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(
  	      'Object/Array as default prop values will be shared ' +
  	      'across multiple instances. Use a factory function ' +
  	      'to return the default value instead.'
  	    )
  	  }
  	  // call factory function for non-Function types
  	  return typeof def === 'function' && options.type !== Function
  	    ? def()
  	    : def
  	}
  
  
  /***/ },
  /* 13 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var Cache = __webpack_require__(14)
  	var config = __webpack_require__(5)
  	var dirParser = __webpack_require__(15)
  	var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
  	var cache, tagRE, htmlRE, firstChar, lastChar
  
  	/**
  	 * Escape a string so it can be used in a RegExp
  	 * constructor.
  	 *
  	 * @param {String} str
  	 */
  
  	function escapeRegex (str) {
  	  return str.replace(regexEscapeRE, '\\$&')
  	}
  
  	/**
  	 * Compile the interpolation tag regex.
  	 *
  	 * @return {RegExp}
  	 */
  
  	function compileRegex () {
  	  config._delimitersChanged = false
  	  var open = config.delimiters[0]
  	  var close = config.delimiters[1]
  	  firstChar = open.charAt(0)
  	  lastChar = close.charAt(close.length - 1)
  	  var firstCharRE = escapeRegex(firstChar)
  	  var lastCharRE = escapeRegex(lastChar)
  	  var openRE = escapeRegex(open)
  	  var closeRE = escapeRegex(close)
  	  tagRE = new RegExp(
  	    firstCharRE + '?' + openRE +
  	    '(.+?)' +
  	    closeRE + lastCharRE + '?',
  	    'g'
  	  )
  	  htmlRE = new RegExp(
  	    '^' + firstCharRE + openRE +
  	    '.*' +
  	    closeRE + lastCharRE + '$'
  	  )
  	  // reset cache
  	  cache = new Cache(1000)
  	}
  
  	/**
  	 * Parse a template text string into an array of tokens.
  	 *
  	 * @param {String} text
  	 * @return {Array<Object> | null}
  	 *               - {String} type
  	 *               - {String} value
  	 *               - {Boolean} [html]
  	 *               - {Boolean} [oneTime]
  	 */
  
  	exports.parse = function (text) {
  	  if (config._delimitersChanged) {
  	    compileRegex()
  	  }
  	  var hit = cache.get(text)
  	  if (hit) {
  	    return hit
  	  }
  	  text = text.replace(/\n/g, '')
  	  if (!tagRE.test(text)) {
  	    return null
  	  }
  	  var tokens = []
  	  var lastIndex = tagRE.lastIndex = 0
  	  var match, index, value, first, oneTime, twoWay
  	  /* 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
  	    first = match[1].charCodeAt(0)
  	    oneTime = first === 42 // *
  	    twoWay = first === 64  // @
  	    value = oneTime || twoWay
  	      ? match[1].slice(1)
  	      : match[1]
  	    tokens.push({
  	      tag: true,
  	      value: value.trim(),
  	      html: htmlRE.test(match[0]),
  	      oneTime: oneTime,
  	      twoWay: twoWay
  	    })
  	    lastIndex = index + match[0].length
  	  }
  	  if (lastIndex < text.length) {
  	    tokens.push({
  	      value: text.slice(lastIndex)
  	    })
  	  }
  	  cache.put(text, tokens)
  	  return tokens
  	}
  
  	/**
  	 * Format a list of tokens into an expression.
  	 * e.g. tokens parsed from 'a {{b}} c' can be serialized
  	 * into one single expression as '"a " + b + " c"'.
  	 *
  	 * @param {Array} tokens
  	 * @param {Vue} [vm]
  	 * @return {String}
  	 */
  
  	exports.tokensToExp = function (tokens, vm) {
  	  return tokens.length > 1
  	    ? tokens.map(function (token) {
  	        return formatToken(token, vm)
  	      }).join('+')
  	    : formatToken(tokens[0], vm, true)
  	}
  
  	/**
  	 * Format a single token.
  	 *
  	 * @param {Object} token
  	 * @param {Vue} [vm]
  	 * @param {Boolean} single
  	 * @return {String}
  	 */
  
  	function formatToken (token, vm, single) {
  	  return token.tag
  	    ? vm && token.oneTime
  	      ? '"' + vm.$eval(token.value) + '"'
  	      : 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 = dirParser.parse(exp)[0]
  	    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?
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 14 */
  /***/ function(module, exports) {
  
  	/**
  	 * A doubly linked list-based Least Recently Used (LRU)
  	 * cache. Will keep most recently used items while
  	 * discarding least recently used items when its limit is
  	 * reached. This is a bare-bone version of
  	 * Rasmus Andersson's js-lru:
  	 *
  	 *   https://github.com/rsms/js-lru
  	 *
  	 * @param {Number} limit
  	 * @constructor
  	 */
  
  	function Cache (limit) {
  	  this.size = 0
  	  this.limit = limit
  	  this.head = this.tail = undefined
  	  this._keymap = 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 entry = {
  	    key: key,
  	    value: value
  	  }
  	  this._keymap[key] = entry
  	  if (this.tail) {
  	    this.tail.newer = entry
  	    entry.older = this.tail
  	  } else {
  	    this.head = entry
  	  }
  	  this.tail = entry
  	  if (this.size === this.limit) {
  	    return this.shift()
  	  } else {
  	    this.size++
  	  }
  	}
  
  	/**
  	 * Purge the least recently used (oldest) entry from the
  	 * cache. Returns the removed entry or undefined if the
  	 * cache was empty.
  	 */
  
  	p.shift = function () {
  	  var entry = this.head
  	  if (entry) {
  	    this.head = this.head.newer
  	    this.head.older = undefined
  	    entry.newer = entry.older = undefined
  	    this._keymap[entry.key] = undefined
  	  }
  	  return entry
  	}
  
  	/**
  	 * Get and register recent use of <key>. Returns the value
  	 * associated with <key> or undefined if not in cache.
  	 *
  	 * @param {String} key
  	 * @param {Boolean} returnEntry
  	 * @return {Entry|*}
  	 */
  
  	p.get = function (key, returnEntry) {
  	  var entry = this._keymap[key]
  	  if (entry === undefined) return
  	  if (entry === this.tail) {
  	    return returnEntry
  	      ? entry
  	      : entry.value
  	  }
  	  // HEAD--------------TAIL
  	  //   <.older   .newer>
  	  //  <--- add direction --
  	  //   A  B  C  <D>  E
  	  if (entry.newer) {
  	    if (entry === this.head) {
  	      this.head = entry.newer
  	    }
  	    entry.newer.older = entry.older // C <-- E.
  	  }
  	  if (entry.older) {
  	    entry.older.newer = entry.newer // C. --> E
  	  }
  	  entry.newer = undefined // D --x
  	  entry.older = this.tail // D. --> E
  	  if (this.tail) {
  	    this.tail.newer = entry // E. <-- D
  	  }
  	  this.tail = entry
  	  return returnEntry
  	    ? entry
  	    : entry.value
  	}
  
  	module.exports = Cache
  
  
  /***/ },
  /* 15 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var Cache = __webpack_require__(14)
  	var cache = new Cache(1000)
  	var argRE = /^[^\{\?]+$|^'[^']*'$|^"[^"]*"$/
  	var filterTokenRE = /[^\s'"]+|'[^']*'|"[^"]*"/g
  	var reservedArgRE = /^in$|^-?\d+/
  
  	/**
  	 * Parser state
  	 */
  
  	var str
  	var c, i, l
  	var inSingle
  	var inDouble
  	var curly
  	var square
  	var paren
  	var begin
  	var argIndex
  	var dirs
  	var dir
  	var lastFilterIndex
  	var arg
  
  	/**
  	 * Push a directive object into the result Array
  	 */
  
  	function pushDir () {
  	  dir.raw = str.slice(begin, i).trim()
  	  if (dir.expression === undefined) {
  	    dir.expression = str.slice(argIndex, i).trim()
  	  } else if (lastFilterIndex !== begin) {
  	    pushFilter()
  	  }
  	  if (i === 0 || dir.expression) {
  	    dirs.push(dir)
  	  }
  	}
  
  	/**
  	 * Push a filter to the current directive object
  	 */
  
  	function pushFilter () {
  	  var exp = str.slice(lastFilterIndex, i).trim()
  	  var filter
  	  if (exp) {
  	    filter = {}
  	    var tokens = exp.match(filterTokenRE)
  	    filter.name = tokens[0]
  	    if (tokens.length > 1) {
  	      filter.args = tokens.slice(1).map(processFilterArg)
  	    }
  	  }
  	  if (filter) {
  	    (dir.filters = dir.filters || []).push(filter)
  	  }
  	  lastFilterIndex = i + 1
  	}
  
  	/**
  	 * Check if an argument is dynamic and strip quotes.
  	 *
  	 * @param {String} arg
  	 * @return {Object}
  	 */
  
  	function processFilterArg (arg) {
  	  var stripped = reservedArgRE.test(arg)
  	    ? arg
  	    : _.stripQuotes(arg)
  	  var dynamic = stripped === false
  	  return {
  	    value: dynamic ? arg : stripped,
  	    dynamic: dynamic
  	  }
  	}
  
  	/**
  	 * Parse a directive string into an Array of AST-like
  	 * objects representing directives.
  	 *
  	 * Example:
  	 *
  	 * "click: a = a + 1 | uppercase" will yield:
  	 * {
  	 *   arg: 'click',
  	 *   expression: 'a = a + 1',
  	 *   filters: [
  	 *     { name: 'uppercase', args: null }
  	 *   ]
  	 * }
  	 *
  	 * @param {String} str
  	 * @return {Array<Object>}
  	 */
  
  	exports.parse = function (s) {
  
  	  var hit = cache.get(s)
  	  if (hit) {
  	    return hit
  	  }
  
  	  // reset parser state
  	  str = s
  	  inSingle = inDouble = false
  	  curly = square = paren = begin = argIndex = 0
  	  lastFilterIndex = 0
  	  dirs = []
  	  dir = {}
  	  arg = null
  
  	  for (i = 0, l = str.length; i < l; i++) {
  	    c = str.charCodeAt(i)
  	    if (inSingle) {
  	      // check single quote
  	      if (c === 0x27) inSingle = !inSingle
  	    } else if (inDouble) {
  	      // check double quote
  	      if (c === 0x22) inDouble = !inDouble
  	    } else if (
  	      c === 0x2C && // comma
  	      !paren && !curly && !square
  	    ) {
  	      // reached the end of a directive
  	      pushDir()
  	      // reset & skip the comma
  	      dir = {}
  	      begin = argIndex = lastFilterIndex = i + 1
  	    } else if (
  	      c === 0x3A && // colon
  	      !dir.expression &&
  	      !dir.arg
  	    ) {
  	      // argument
  	      arg = str.slice(begin, i).trim()
  	      // test for valid argument here
  	      // since we may have caught stuff like first half of
  	      // an object literal or a ternary expression.
  	      if (argRE.test(arg)) {
  	        argIndex = i + 1
  	        dir.arg = _.stripQuotes(arg) || arg
  	      }
  	    } else if (
  	      c === 0x7C && // pipe
  	      str.charCodeAt(i + 1) !== 0x7C &&
  	      str.charCodeAt(i - 1) !== 0x7C
  	    ) {
  	      if (dir.expression === undefined) {
  	        // first filter, end of expression
  	        lastFilterIndex = i + 1
  	        dir.expression = str.slice(argIndex, i).trim()
  	      } else {
  	        // already has filter
  	        pushFilter()
  	      }
  	    } else {
  	      switch (c) {
  	        case 0x22: inDouble = true; break // "
  	        case 0x27: inSingle = true; break // '
  	        case 0x28: paren++; break         // (
  	        case 0x29: paren--; break         // )
  	        case 0x5B: square++; break        // [
  	        case 0x5D: square--; break        // ]
  	        case 0x7B: curly++; break         // {
  	        case 0x7D: curly--; break         // }
  	      }
  	    }
  	  }
  
  	  if (i === 0 || begin !== i) {
  	    pushDir()
  	  }
  
  	  cache.put(s, dirs)
  	  return dirs
  	}
  
  
  /***/ },
  /* 16 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// NOTE: the prop internal directive is compiled and linked
  	// during _initScope(), before the created hook is called.
  	// The purpose is to make the initial prop values available
  	// inside `created` hooks and `data` functions.
  
  	var _ = __webpack_require__(1)
  	var Watcher = __webpack_require__(17)
  	var bindingModes = __webpack_require__(5)._propBindingModes
  
  	module.exports = {
  
  	  bind: function () {
  
  	    var child = this.vm
  	    var parent = child._context
  	    // passed in from compiler directly
  	    var prop = this._descriptor
  	    var childKey = prop.path
  	    var parentKey = prop.parentPath
  
  	    this.parentWatcher = new Watcher(
  	      parent,
  	      parentKey,
  	      function (val) {
  	        if (_.assertProp(prop, val)) {
  	          child[childKey] = val
  	        }
  	      }, { sync: true }
  	    )
  
  	    // set the child initial value.
  	    var value = this.parentWatcher.value
  	    if (childKey === '$data') {
  	      child._data = value
  	    } else {
  	      _.initProp(child, prop, value)
  	    }
  
  	    // setup two-way binding
  	    if (prop.mode === bindingModes.TWO_WAY) {
  	      // important: defer the child watcher creation until
  	      // the created hook (after data observation)
  	      var self = this
  	      child.$once('hook:created', function () {
  	        self.childWatcher = new Watcher(
  	          child,
  	          childKey,
  	          function (val) {
  	            parent.$set(parentKey, val)
  	          }, { sync: true }
  	        )
  	      })
  	    }
  	  },
  
  	  unbind: function () {
  	    this.parentWatcher.teardown()
  	    if (this.childWatcher) {
  	      this.childWatcher.teardown()
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 17 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  	var Dep = __webpack_require__(18)
  	var expParser = __webpack_require__(19)
  	var batcher = __webpack_require__(21)
  	var uid = 0
  
  	/**
  	 * A watcher parses an expression, collects dependencies,
  	 * and fires callback when the expression value changes.
  	 * This is used for both the $watch() api and directives.
  	 *
  	 * @param {Vue} vm
  	 * @param {String} expression
  	 * @param {Function} cb
  	 * @param {Object} options
  	 *                 - {Array} filters
  	 *                 - {Boolean} twoWay
  	 *                 - {Boolean} deep
  	 *                 - {Boolean} user
  	 *                 - {Boolean} sync
  	 *                 - {Boolean} lazy
  	 *                 - {Function} [preProcess]
  	 * @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 = isFn ? expOrFn.toString() : expOrFn
  	  this.cb = cb
  	  this.id = ++uid // uid for batching
  	  this.active = true
  	  this.dirty = this.lazy // for lazy watchers
  	  this.deps = []
  	  this.newDeps = null
  	  this.prevError = null // for async error stacks
  	  // parse expression for getter/setter
  	  if (isFn) {
  	    this.getter = expOrFn
  	    this.setter = undefined
  	  } else {
  	    var res = expParser.parse(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
  	}
  
  	/**
  	 * Add a dependency to this directive.
  	 *
  	 * @param {Dep} dep
  	 */
  
  	Watcher.prototype.addDep = function (dep) {
  	  var newDeps = this.newDeps
  	  var old = this.deps
  	  if (_.indexOf(newDeps, dep) < 0) {
  	    newDeps.push(dep)
  	    var i = _.indexOf(old, dep)
  	    if (i < 0) {
  	      dep.addSub(this)
  	    } else {
  	      old[i] = null
  	    }
  	  }
  	}
  
  	/**
  	 * Evaluate the getter, and re-collect dependencies.
  	 */
  
  	Watcher.prototype.get = function () {
  	  this.beforeGet()
  	  var vm = this.vm
  	  var value
  	  try {
  	    value = this.getter.call(vm, vm)
  	  } catch (e) {
  	    if (
  	      ("development") !== 'production' &&
  	      config.warnExpressionErrors
  	    ) {
  	      _.warn(
  	        'Error when evaluating expression "' +
  	        this.expression + '". ' +
  	        (config.debug
  	          ? '' :
  	          'Turn on debug mode to see stack trace.'
  	        ), e
  	      )
  	    }
  	  }
  	  // "touch" every property so they are all tracked as
  	  // dependencies for deep watching
  	  if (this.deep) {
  	    traverse(value)
  	  }
  	  if (this.preProcess) {
  	    value = this.preProcess(value)
  	  }
  	  if (this.filters) {
  	    value = vm._applyFilters(value, null, this.filters, false)
  	  }
  	  this.afterGet()
  	  return value
  	}
  
  	/**
  	 * Set the corresponding value with the setter.
  	 *
  	 * @param {*} value
  	 */
  
  	Watcher.prototype.set = function (value) {
  	  var vm = this.vm
  	  if (this.filters) {
  	    value = vm._applyFilters(
  	      value, this.value, this.filters, true)
  	  }
  	  try {
  	    this.setter.call(vm, vm, value)
  	  } catch (e) {
  	    if (
  	      ("development") !== 'production' &&
  	      config.warnExpressionErrors
  	    ) {
  	      _.warn(
  	        'Error when evaluating setter "' +
  	        this.expression + '"', e
  	      )
  	    }
  	  }
  	}
  
  	/**
  	 * Prepare for dependency collection.
  	 */
  
  	Watcher.prototype.beforeGet = function () {
  	  Dep.target = this
  	  this.newDeps = []
  	}
  
  	/**
  	 * 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 (dep) {
  	      dep.removeSub(this)
  	    }
  	  }
  	  this.deps = this.newDeps
  	  this.newDeps = null
  	}
  
  	/**
  	 * 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')
  	    }
  	    batcher.push(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 Array watchers 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).
  	      ((_.isArray(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
  	    // we can skip this if the vm if being destroyed
  	    // which can improve teardown performance.
  	    if (!this.vm._isBeingDestroyed) {
  	      this.vm._watchers.$remove(this)
  	    }
  	    var i = this.deps.length
  	    while (i--) {
  	      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 {Object} obj
  	 */
  
  	function traverse (obj) {
  	  var key, val, i
  	  for (key in obj) {
  	    val = obj[key]
  	    if (_.isArray(val)) {
  	      i = val.length
  	      while (i--) traverse(val[i])
  	    } else if (_.isObject(val)) {
  	      traverse(val)
  	    }
  	  }
  	}
  
  	module.exports = Watcher
  
  
  /***/ },
  /* 18 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	/**
  	 * A dep is an observable that can have multiple
  	 * directives subscribing to it.
  	 *
  	 * @constructor
  	 */
  
  	function Dep () {
  	  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()
  	  }
  	}
  
  	module.exports = Dep
  
  
  /***/ },
  /* 19 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var Path = __webpack_require__(20)
  	var Cache = __webpack_require__(14)
  	var expressionCache = new Cache(1000)
  
  	var allowedKeywords =
  	  'Math,Date,this,true,false,null,undefined,Infinity,NaN,' +
  	  'isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,' +
  	  'encodeURIComponent,parseInt,parseFloat'
  	var allowedKeywordsRE =
  	  new RegExp('^(' + allowedKeywords.replace(/,/g, '\\b|') + '\\b)')
  
  	// keywords that don't make sense inside expressions
  	var improperKeywords =
  	  'break,case,class,catch,const,continue,debugger,default,' +
  	  'delete,do,else,export,extends,finally,for,function,if,' +
  	  'import,in,instanceof,let,return,super,switch,throw,try,' +
  	  'var,while,with,yield,enum,await,implements,package,' +
  	  'proctected,static,interface,private,public'
  	var improperKeywordsRE =
  	  new RegExp('^(' + improperKeywords.replace(/,/g, '\\b|') + '\\b)')
  
  	var wsRE = /\s/g
  	var newlineRE = /\n/g
  	var saveRE = /[\{,]\s*[\w\$_]+\s*:|('[^']*'|"[^"]*")|new |typeof |void /g
  	var restoreRE = /"(\d+)"/g
  	var pathTestRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/
  	var pathReplaceRE = /[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g
  	var booleanLiteralRE = /^(true|false)$/
  
  	/**
  	 * Save / Rewrite / Restore
  	 *
  	 * When rewriting paths found in an expression, it is
  	 * possible for the same letter sequences to be found in
  	 * strings and Object literal property keys. Therefore we
  	 * remove and store these parts in a temporary array, and
  	 * restore them after the path rewrite.
  	 */
  
  	var saved = []
  
  	/**
  	 * Save replacer
  	 *
  	 * The save regex can match two possible cases:
  	 * 1. An opening object literal
  	 * 2. A string
  	 * If matched as a plain string, we need to escape its
  	 * newlines, since the string needs to be preserved when
  	 * generating the function body.
  	 *
  	 * @param {String} str
  	 * @param {String} isString - str if matched as a string
  	 * @return {String} - placeholder with index
  	 */
  
  	function save (str, isString) {
  	  var i = saved.length
  	  saved[i] = isString
  	    ? str.replace(newlineRE, '\\n')
  	    : str
  	  return '"' + i + '"'
  	}
  
  	/**
  	 * 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
  	 * @param {Boolean} needSet
  	 * @return {Function}
  	 */
  
  	function compileExpFns (exp, needSet) {
  	  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 becaue the regex matches 1 extra char
  	  body = (' ' + body)
  	    .replace(pathReplaceRE, rewrite)
  	    .replace(restoreRE, restore)
  	  var getter = makeGetter(body)
  	  if (getter) {
  	    return {
  	      get: getter,
  	      body: body,
  	      set: needSet
  	        ? makeSetter(body)
  	        : null
  	    }
  	  }
  	}
  
  	/**
  	 * Compile getter setters for a simple path.
  	 *
  	 * @param {String} exp
  	 * @return {Function}
  	 */
  
  	function compilePathFns (exp) {
  	  var getter, path
  	  if (exp.indexOf('[') < 0) {
  	    // really simple path
  	    path = exp.split('.')
  	    path.raw = exp
  	    getter = Path.compileGetter(path)
  	  } else {
  	    // do the real parsing
  	    path = Path.parse(exp)
  	    getter = path.get
  	  }
  	  return {
  	    get: getter,
  	    // always generate setter for simple paths
  	    set: function (obj, val) {
  	      Path.set(obj, path, val)
  	    }
  	  }
  	}
  
  	/**
  	 * Build a getter function. Requires eval.
  	 *
  	 * We isolate the try/catch so it doesn't affect the
  	 * optimization of the parse function when it is not called.
  	 *
  	 * @param {String} body
  	 * @return {Function|undefined}
  	 */
  
  	function makeGetter (body) {
  	  try {
  	    return new Function('scope', 'return ' + body + ';')
  	  } catch (e) {
  	    ("development") !== 'production' && _.warn(
  	      'Invalid expression. ' +
  	      'Generated function body: ' + body
  	    )
  	  }
  	}
  
  	/**
  	 * Build a setter function.
  	 *
  	 * This is only needed in rare situations like "a[b]" where
  	 * a settable path requires dynamic evaluation.
  	 *
  	 * This setter function may throw error when called if the
  	 * expression body is not a valid left-hand expression in
  	 * assignment.
  	 *
  	 * @param {String} body
  	 * @return {Function|undefined}
  	 */
  
  	function makeSetter (body) {
  	  try {
  	    return new Function('scope', 'value', body + '=value;')
  	  } catch (e) {
  	    ("development") !== 'production' && _.warn(
  	      'Invalid setter function body: ' + body
  	    )
  	  }
  	}
  
  	/**
  	 * Check for setter existence on a cache hit.
  	 *
  	 * @param {Function} hit
  	 */
  
  	function checkSetter (hit) {
  	  if (!hit.set) {
  	    hit.set = makeSetter(hit.body)
  	  }
  	}
  
  	/**
  	 * Parse an expression into re-written getter/setters.
  	 *
  	 * @param {String} exp
  	 * @param {Boolean} needSet
  	 * @return {Function}
  	 */
  
  	exports.parse = function (exp, needSet) {
  	  exp = exp.trim()
  	  // try cache
  	  var hit = expressionCache.get(exp)
  	  if (hit) {
  	    if (needSet) {
  	      checkSetter(hit)
  	    }
  	    return hit
  	  }
  	  // we do a simple path check to optimize for them.
  	  // the check fails valid paths with unusal whitespaces,
  	  // but that's too rare and we don't care.
  	  // also skip boolean literals and paths that start with
  	  // global "Math"
  	  var res = exports.isSimplePath(exp)
  	    ? compilePathFns(exp)
  	    : compileExpFns(exp, needSet)
  	  expressionCache.put(exp, res)
  	  return res
  	}
  
  	/**
  	 * Check if an expression is a simple path.
  	 *
  	 * @param {String} exp
  	 * @return {Boolean}
  	 */
  
  	exports.isSimplePath = function (exp) {
  	  return pathTestRE.test(exp) &&
  	    // don't treat true/false as paths
  	    !booleanLiteralRE.test(exp) &&
  	    // Math constants e.g. Math.PI, Math.E etc.
  	    exp.slice(0, 5) !== 'Math.'
  	}
  
  
  /***/ },
  /* 20 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var Cache = __webpack_require__(14)
  	var pathCache = new Cache(1000)
  	var identRE = exports.identRE = /^[$_a-zA-Z]+[\w$]*$/
  
  	// actions
  	var APPEND = 0
  	var PUSH = 1
  
  	// states
  	var BEFORE_PATH = 0
  	var IN_PATH = 1
  	var BEFORE_IDENT = 2
  	var IN_IDENT = 3
  	var BEFORE_ELEMENT = 4
  	var AFTER_ZERO = 5
  	var IN_INDEX = 6
  	var IN_SINGLE_QUOTE = 7
  	var IN_DOUBLE_QUOTE = 8
  	var IN_SUB_PATH = 9
  	var AFTER_ELEMENT = 10
  	var AFTER_PATH = 11
  	var ERROR = 12
  
  	var pathStateMachine = []
  
  	pathStateMachine[BEFORE_PATH] = {
  	  'ws': [BEFORE_PATH],
  	  'ident': [IN_IDENT, APPEND],
  	  '[': [BEFORE_ELEMENT],
  	  'eof': [AFTER_PATH]
  	}
  
  	pathStateMachine[IN_PATH] = {
  	  'ws': [IN_PATH],
  	  '.': [BEFORE_IDENT],
  	  '[': [BEFORE_ELEMENT],
  	  '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],
  	  '[': [BEFORE_ELEMENT, PUSH],
  	  'eof': [AFTER_PATH, PUSH]
  	}
  
  	pathStateMachine[BEFORE_ELEMENT] = {
  	  'ws': [BEFORE_ELEMENT],
  	  '0': [AFTER_ZERO, APPEND],
  	  'number': [IN_INDEX, APPEND],
  	  "'": [IN_SINGLE_QUOTE, APPEND, ''],
  	  '"': [IN_DOUBLE_QUOTE, APPEND, ''],
  	  'ident': [IN_SUB_PATH, APPEND, '*']
  	}
  
  	pathStateMachine[AFTER_ZERO] = {
  	  'ws': [AFTER_ELEMENT, PUSH],
  	  ']': [IN_PATH, PUSH]
  	}
  
  	pathStateMachine[IN_INDEX] = {
  	  '0': [IN_INDEX, APPEND],
  	  'number': [IN_INDEX, APPEND],
  	  'ws': [AFTER_ELEMENT],
  	  ']': [IN_PATH, PUSH]
  	}
  
  	pathStateMachine[IN_SINGLE_QUOTE] = {
  	  "'": [AFTER_ELEMENT],
  	  'eof': ERROR,
  	  'else': [IN_SINGLE_QUOTE, APPEND]
  	}
  
  	pathStateMachine[IN_DOUBLE_QUOTE] = {
  	  '"': [AFTER_ELEMENT],
  	  'eof': ERROR,
  	  'else': [IN_DOUBLE_QUOTE, APPEND]
  	}
  
  	pathStateMachine[IN_SUB_PATH] = {
  	  'ident': [IN_SUB_PATH, APPEND],
  	  '0': [IN_SUB_PATH, APPEND],
  	  'number': [IN_SUB_PATH, APPEND],
  	  'ws': [AFTER_ELEMENT],
  	  ']': [IN_PATH, PUSH]
  	}
  
  	pathStateMachine[AFTER_ELEMENT] = {
  	  'ws': [AFTER_ELEMENT],
  	  ']': [IN_PATH, PUSH]
  	}
  
  	/**
  	 * 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'
  	}
  
  	/**
  	 * Parse a string path into an array of segments
  	 * Todo implement cache
  	 *
  	 * @param {String} path
  	 * @return {Array|undefined}
  	 */
  
  	function parsePath (path) {
  	  var keys = []
  	  var index = -1
  	  var mode = BEFORE_PATH
  	  var c, newChar, key, type, transition, action, typeMap
  
  	  var actions = []
  	  actions[PUSH] = function () {
  	    if (key === undefined) {
  	      return
  	    }
  	    keys.push(key)
  	    key = undefined
  	  }
  	  actions[APPEND] = function () {
  	    if (key === undefined) {
  	      key = newChar
  	    } else {
  	      key += newChar
  	    }
  	  }
  
  	  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 === '*'
  	          ? newChar + c
  	          : newChar
  	      action()
  	    }
  
  	    if (mode === AFTER_PATH) {
  	      keys.raw = path
  	      return keys
  	    }
  	  }
  	}
  
  	/**
  	 * Format a accessor segment based on its type.
  	 *
  	 * @param {String} key
  	 * @return {Boolean}
  	 */
  
  	function formatAccessor (key) {
  	  if (identRE.test(key)) { // identifier
  	    return '.' + key
  	  } else if (+key === key >>> 0) { // bracket index
  	    return '[' + key + ']'
  	  } else if (key.charAt(0) === '*') {
  	    return '[o' + formatAccessor(key.slice(1)) + ']'
  	  } else { // bracket string
  	    return '["' + key.replace(/"/g, '\\"') + '"]'
  	  }
  	}
  
  	/**
  	 * Compiles a getter function with a fixed path.
  	 * The fixed path getter supresses errors.
  	 *
  	 * @param {Array} path
  	 * @return {Function}
  	 */
  
  	exports.compileGetter = function (path) {
  	  var body = 'return o' + path.map(formatAccessor).join('')
  	  return new Function('o', body)
  	}
  
  	/**
  	 * External parse that check for a cache hit first
  	 *
  	 * @param {String} path
  	 * @return {Array|undefined}
  	 */
  
  	exports.parse = function (path) {
  	  var hit = pathCache.get(path)
  	  if (!hit) {
  	    hit = parsePath(path)
  	    if (hit) {
  	      hit.get = exports.compileGetter(hit)
  	      pathCache.put(path, hit)
  	    }
  	  }
  	  return hit
  	}
  
  	/**
  	 * Get from an object from a path string
  	 *
  	 * @param {Object} obj
  	 * @param {String} path
  	 */
  
  	exports.get = function (obj, path) {
  	  path = exports.parse(path)
  	  if (path) {
  	    return path.get(obj)
  	  }
  	}
  
  	/**
  	 * Set on an object from a path
  	 *
  	 * @param {Object} obj
  	 * @param {String | Array} path
  	 * @param {*} val
  	 */
  
  	exports.set = function (obj, path, val) {
  	  var original = obj
  	  if (typeof path === 'string') {
  	    path = exports.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 = original[key.slice(1)]
  	    }
  	    if (i < l - 1) {
  	      obj = obj[key]
  	      if (!_.isObject(obj)) {
  	        warnNonExistent(path)
  	        obj = {}
  	        last.$add(key, obj)
  	      }
  	    } else {
  	      if (_.isArray(obj)) {
  	        obj.$set(key, val)
  	      } else if (key in obj) {
  	        obj[key] = val
  	      } else {
  	        warnNonExistent(path)
  	        obj.$add(key, val)
  	      }
  	    }
  	  }
  	  return true
  	}
  
  	function warnNonExistent (path) {
  	  ("development") !== 'production' && _.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.'
  	  )
  	}
  
  
  /***/ },
  /* 21 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  
  	// 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
  	var internalQueueDepleted = false
  
  	/**
  	 * Reset the batcher's state.
  	 */
  
  	function resetBatcherState () {
  	  queue = []
  	  userQueue = []
  	  has = {}
  	  circular = {}
  	  waiting = internalQueueDepleted = false
  	}
  
  	/**
  	 * Flush both queues and run the watchers.
  	 */
  
  	function flushBatcherQueue () {
  	  runBatcherQueue(queue)
  	  internalQueueDepleted = true
  	  runBatcherQueue(userQueue)
  	  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) {
  	        queue.splice(has[id], 1)
  	        _.warn(
  	          'You may have an infinite update loop for watcher ' +
  	          'with expression: ' + watcher.expression
  	        )
  	      }
  	    }
  	  }
  	}
  
  	/**
  	 * 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
  	 */
  
  	exports.push = function (watcher) {
  	  var id = watcher.id
  	  if (has[id] == null) {
  	    // if an internal watcher is pushed, but the internal
  	    // queue is already depleted, we run it immediately.
  	    if (internalQueueDepleted && !watcher.user) {
  	      watcher.run()
  	      return
  	    }
  	    // 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)
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 22 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var Cache = __webpack_require__(14)
  	var templateCache = new Cache(1000)
  	var idSelectorCache = new Cache(1000)
  
  	var map = {
  	  _default: [0, '', ''],
  	  legend: [1, '<fieldset>', '</fieldset>'],
  	  tr: [2, '<table><tbody>', '</tbody></table>'],
  	  col: [
  	    2,
  	    '<table><tbody></tbody><colgroup>',
  	    '</colgroup></table>'
  	  ]
  	}
  
  	map.td =
  	map.th = [
  	  3,
  	  '<table><tbody><tr>',
  	  '</tr></tbody></table>'
  	]
  
  	map.option =
  	map.optgroup = [
  	  1,
  	  '<select multiple="multiple">',
  	  '</select>'
  	]
  
  	map.thead =
  	map.tbody =
  	map.colgroup =
  	map.caption =
  	map.tfoot = [1, '<table>', '</table>']
  
  	map.g =
  	map.defs =
  	map.symbol =
  	map.use =
  	map.image =
  	map.text =
  	map.circle =
  	map.ellipse =
  	map.line =
  	map.path =
  	map.polygon =
  	map.polyline =
  	map.rect = [
  	  1,
  	  '<svg ' +
  	    'xmlns="http://www.w3.org/2000/svg" ' +
  	    'xmlns:xlink="http://www.w3.org/1999/xlink" ' +
  	    'xmlns:ev="http://www.w3.org/2001/xml-events"' +
  	    'version="1.1">',
  	  '</svg>'
  	]
  
  	/**
  	 * Check if a node is a supported template node with a
  	 * DocumentFragment content.
  	 *
  	 * @param {Node} node
  	 * @return {Boolean}
  	 */
  
  	function isRealTemplate (node) {
  	  return _.isTemplate(node) &&
  	    node.content instanceof DocumentFragment
  	}
  
  	var tagRE = /<([\w:]+)/
  	var entityRE = /&\w+;/
  
  	/**
  	 * Convert a string template to a DocumentFragment.
  	 * Determines correct wrapping by tag types. Wrapping
  	 * strategy found in jQuery & component/domify.
  	 *
  	 * @param {String} templateString
  	 * @return {DocumentFragment}
  	 */
  
  	function stringToFragment (templateString) {
  	  // try a cache hit first
  	  var hit = templateCache.get(templateString)
  	  if (hit) {
  	    return hit
  	  }
  
  	  var frag = document.createDocumentFragment()
  	  var tagMatch = templateString.match(tagRE)
  	  var entityMatch = entityRE.test(templateString)
  
  	  if (!tagMatch && !entityMatch) {
  	    // text only, return a single text node.
  	    frag.appendChild(
  	      document.createTextNode(templateString)
  	    )
  	  } else {
  
  	    var tag = tagMatch && tagMatch[1]
  	    var wrap = map[tag] || map._default
  	    var depth = wrap[0]
  	    var prefix = wrap[1]
  	    var suffix = wrap[2]
  	    var node = document.createElement('div')
  
  	    node.innerHTML = prefix + templateString.trim() + suffix
  	    while (depth--) {
  	      node = node.lastChild
  	    }
  
  	    var child
  	    /* eslint-disable no-cond-assign */
  	    while (child = node.firstChild) {
  	    /* eslint-enable no-cond-assign */
  	      frag.appendChild(child)
  	    }
  	  }
  
  	  templateCache.put(templateString, 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.
  	  if (isRealTemplate(node)) {
  	    _.trimNode(node.content)
  	    return node.content
  	  }
  	  // script template
  	  if (node.tagName === 'SCRIPT') {
  	    return stringToFragment(node.textContent)
  	  }
  	  // normal node, clone it to avoid mutating the original
  	  var clone = exports.clone(node)
  	  var frag = document.createDocumentFragment()
  	  var child
  	  /* eslint-disable no-cond-assign */
  	  while (child = clone.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/show_bug.cgi?id=137755
  	var hasBrokenTemplate = _.inBrowser
  	  ? (function () {
  	      var a = document.createElement('div')
  	      a.innerHTML = '<template>1</template>'
  	      return !a.cloneNode(true).firstChild.innerHTML
  	    })()
  	  : false
  
  	// Test for IE10/11 textarea placeholder clone bug
  	var hasTextareaCloneBug = _.inBrowser
  	  ? (function () {
  	      var t = document.createElement('textarea')
  	      t.placeholder = 't'
  	      return t.cloneNode(true).value === 't'
  	    })()
  	  : false
  
  	/**
  	 * 1. Deal with Safari cloning nested <template> bug by
  	 *    manually cloning all template instances.
  	 * 2. Deal with IE10/11 textarea placeholder bug by setting
  	 *    the correct value after cloning.
  	 *
  	 * @param {Element|DocumentFragment} node
  	 * @return {Element|DocumentFragment}
  	 */
  
  	exports.clone = function (node) {
  	  if (!node.querySelectorAll) {
  	    return node.cloneNode()
  	  }
  	  var res = node.cloneNode(true)
  	  var i, original, cloned
  	  /* istanbul ignore if */
  	  if (hasBrokenTemplate) {
  	    var clone = res
  	    if (isRealTemplate(node)) {
  	      node = node.content
  	      clone = res.content
  	    }
  	    original = node.querySelectorAll('template')
  	    if (original.length) {
  	      cloned = clone.querySelectorAll('template')
  	      i = cloned.length
  	      while (i--) {
  	        cloned[i].parentNode.replaceChild(
  	          exports.clone(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} clone
  	 * @param {Boolean} noSelector
  	 * @return {DocumentFragment|undefined}
  	 */
  
  	exports.parse = function (template, clone, noSelector) {
  	  var node, frag
  
  	  // if the template is already a document fragment,
  	  // do nothing
  	  if (template instanceof DocumentFragment) {
  	    _.trimNode(template)
  	    return clone
  	      ? exports.clone(template)
  	      : template
  	  }
  
  	  if (typeof template === 'string') {
  	    // id selector
  	    if (!noSelector && template.charAt(0) === '#') {
  	      // id selector can be cached too
  	      frag = idSelectorCache.get(template)
  	      if (!frag) {
  	        node = document.getElementById(template.slice(1))
  	        if (node) {
  	          frag = nodeToFragment(node)
  	          // save selector to cache
  	          idSelectorCache.put(template, frag)
  	        }
  	      }
  	    } else {
  	      // normal string template
  	      frag = stringToFragment(template)
  	    }
  	  } else if (template.nodeType) {
  	    // a direct node
  	    frag = nodeToFragment(template)
  	  }
  
  	  return frag && clone
  	    ? exports.clone(frag)
  	    : frag
  	}
  
  
  /***/ },
  /* 23 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  	var templateParser = __webpack_require__(22)
  
  	module.exports = {
  
  	  isLiteral: true,
  
  	  /**
  	   * Setup. Two possible usages:
  	   *
  	   * - static:
  	   *   v-component="comp"
  	   *
  	   * - dynamic:
  	   *   v-component="{{currentView}}"
  	   */
  
  	  bind: function () {
  	    if (!this.el.__vue__) {
  	      // create a ref anchor
  	      this.anchor = _.createAnchor('v-component')
  	      _.replace(this.el, this.anchor)
  	      // check keep-alive options.
  	      // If yes, instead of destroying the active vm when
  	      // hiding (v-if) or switching (dynamic literal) it,
  	      // we simply remove it from the DOM and save it in a
  	      // cache object, with its constructor id as the key.
  	      this.keepAlive = this._checkParam('keep-alive') != null
  	      // wait for event before insertion
  	      this.waitForEvent = this._checkParam('wait-for')
  	      // check ref
  	      this.refID = this._checkParam(config.prefix + 'ref')
  	      if (this.keepAlive) {
  	        this.cache = {}
  	      }
  	      // check inline-template
  	      if (this._checkParam('inline-template') !== null) {
  	        // extract inline template as a DocumentFragment
  	        this.template = _.extractContent(this.el, true)
  	      }
  	      // component resolution related state
  	      this.pendingComponentCb =
  	      this.Component = null
  	      // transition related state
  	      this.pendingRemovals = 0
  	      this.pendingRemovalCb = null
  	      // if static, build right now.
  	      if (!this._isDynamicLiteral) {
  	        this.resolveComponent(this.expression, _.bind(this.initStatic, this))
  	      } else {
  	        // check dynamic component params
  	        this.transMode = this._checkParam('transition-mode')
  	      }
  	    } else {
  	      ("development") !== 'production' && _.warn(
  	        'cannot mount component "' + this.expression + '" ' +
  	        'on already mounted element: ' + this.el
  	      )
  	    }
  	  },
  
  	  /**
  	   * Initialize a static component.
  	   */
  
  	  initStatic: function () {
  	    // wait-for
  	    var anchor = this.anchor
  	    var options
  	    var waitFor = this.waitForEvent
  	    if (waitFor) {
  	      options = {
  	        created: function () {
  	          this.$once(waitFor, function () {
  	            this.$before(anchor)
  	          })
  	        }
  	      }
  	    }
  	    var child = this.build(options)
  	    this.setCurrent(child)
  	    if (!this.waitForEvent) {
  	      child.$before(anchor)
  	    }
  	  },
  
  	  /**
  	   * Public update, called by the watcher in the dynamic
  	   * literal scenario, e.g. v-component="{{view}}"
  	   */
  
  	  update: function (value) {
  	    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 (value, cb) {
  	    this.invalidatePending()
  	    if (!value) {
  	      // just remove current
  	      this.unbuild(true)
  	      this.remove(this.childVM, cb)
  	      this.unsetCurrent()
  	    } else {
  	      this.resolveComponent(value, _.bind(function () {
  	        this.unbuild(true)
  	        var options
  	        var self = this
  	        var waitFor = this.waitForEvent
  	        if (waitFor) {
  	          options = {
  	            created: function () {
  	              this.$once(waitFor, function () {
  	                self.waitingFor = null
  	                self.transition(this, cb)
  	              })
  	            }
  	          }
  	        }
  	        var cached = this.getCached()
  	        var newComponent = this.build(options)
  	        if (!waitFor || cached) {
  	          this.transition(newComponent, cb)
  	        } else {
  	          this.waitingFor = newComponent
  	        }
  	      }, this))
  	    }
  	  },
  
  	  /**
  	   * Resolve the component constructor to use when creating
  	   * the child vm.
  	   */
  
  	  resolveComponent: function (id, cb) {
  	    var self = this
  	    this.pendingComponentCb = _.cancellable(function (Component) {
  	      self.Component = Component
  	      cb()
  	    })
  	    this.vm._resolveComponent(id, this.pendingComponentCb)
  	  },
  
  	  /**
  	   * When the component changes or unbinds before an async
  	   * constructor is resolved, we need to invalidate its
  	   * pending callback.
  	   */
  
  	  invalidatePending: function () {
  	    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 (extraOptions) {
  	    var cached = this.getCached()
  	    if (cached) {
  	      return cached
  	    }
  	    if (this.Component) {
  	      // default options
  	      var options = {
  	        el: templateParser.clone(this.el),
  	        template: this.template,
  	        // if no inline-template, then the compiled
  	        // linker can be cached for better performance.
  	        _linkerCachable: !this.template,
  	        _asComponent: true,
  	        _isRouterView: this._isRouterView,
  	        _context: this.vm
  	      }
  	      // extra options
  	      if (extraOptions) {
  	        _.extend(options, extraOptions)
  	      }
  	      var parent = this._host || this.vm
  	      var child = parent.$addChild(options, this.Component)
  	      if (this.keepAlive) {
  	        this.cache[this.Component.cid] = child
  	      }
  	      return child
  	    }
  	  },
  
  	  /**
  	   * Try to get a cached instance of the current component.
  	   *
  	   * @return {Vue|undefined}
  	   */
  
  	  getCached: function () {
  	    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 (defer) {
  	    if (this.waitingFor) {
  	      this.waitingFor.$destroy()
  	      this.waitingFor = null
  	    }
  	    var child = this.childVM
  	    if (!child || this.keepAlive) {
  	      return
  	    }
  	    // the sole purpose of `deferCleanup` is so that we can
  	    // "deactivate" the vm right now and perform DOM removal
  	    // later.
  	    child.$destroy(false, defer)
  	  },
  
  	  /**
  	   * Remove current destroyed child and manually do
  	   * the cleanup after removal.
  	   *
  	   * @param {Function} cb
  	   */
  
  	  remove: function (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 (target, cb) {
  	    var self = this
  	    var current = this.childVM
  	    this.setCurrent(target)
  	    switch (self.transMode) {
  	      case 'in-out':
  	        target.$before(self.anchor, function () {
  	          self.remove(current, cb)
  	        })
  	        break
  	      case 'out-in':
  	        self.remove(current, function () {
  	          target.$before(self.anchor, cb)
  	        })
  	        break
  	      default:
  	        self.remove(current)
  	        target.$before(self.anchor, cb)
  	    }
  	  },
  
  	  /**
  	   * Set childVM and parent ref
  	   */
  
  	  setCurrent: function (child) {
  	    this.unsetCurrent()
  	    this.childVM = child
  	    var refID = child._refID || this.refID
  	    if (refID) {
  	      this.vm.$[refID] = child
  	    }
  	  },
  
  	  /**
  	   * Unset childVM and parent ref
  	   */
  
  	  unsetCurrent: function () {
  	    var child = this.childVM
  	    this.childVM = null
  	    var refID = (child && child._refID) || this.refID
  	    if (refID) {
  	      this.vm.$[refID] = null
  	    }
  	  },
  
  	  /**
  	   * Unbind.
  	   */
  
  	  unbind: function () {
  	    this.invalidatePending()
  	    // Do not defer cleanup when unbinding
  	    this.unbuild()
  	    this.unsetCurrent()
  	    // destroy all keep-alive cached instances
  	    if (this.cache) {
  	      for (var key in this.cache) {
  	        this.cache[key].$destroy()
  	      }
  	      this.cache = null
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 24 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  	var templateParser = __webpack_require__(22)
  
  	/**
  	 * Process an element or a DocumentFragment based on a
  	 * instance option object. This allows us to transclude
  	 * a template node/fragment before the instance is created,
  	 * so the processed fragment can then be cloned and reused
  	 * in v-repeat.
  	 *
  	 * @param {Element} el
  	 * @param {Object} options
  	 * @return {Element|DocumentFragment}
  	 */
  
  	exports.transclude = function (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 = templateParser.parse(el)
  	  }
  	  if (options) {
  	    if (options._asComponent && !options.template) {
  	      options.template = '<content></content>'
  	    }
  	    if (options.template) {
  	      options._content = _.extractContent(el)
  	      el = transcludeTemplate(el, options)
  	    }
  	  }
  	  if (el instanceof DocumentFragment) {
  	    // 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 = templateParser.parse(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) ||
  	        replacer.hasAttribute(config.prefix + 'component') ||
  	        // element directive
  	        _.resolveAsset(options, 'elementDirectives', tag) ||
  	        // repeat block
  	        replacer.hasAttribute(config.prefix + 'repeat')
  	      ) {
  	        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)) {
  	      to.setAttribute(name, value)
  	    } else if (name === 'class') {
  	      value = to.getAttribute(name) + ' ' + value
  	      to.setAttribute(name, value)
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 25 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// manipulation directives
  	exports.text = __webpack_require__(26)
  	exports.html = __webpack_require__(27)
  	exports.attr = __webpack_require__(28)
  	exports.show = __webpack_require__(29)
  	exports['class'] = __webpack_require__(31)
  	exports.el = __webpack_require__(32)
  	exports.ref = __webpack_require__(33)
  	exports.cloak = __webpack_require__(34)
  	exports.style = __webpack_require__(35)
  	exports.transition = __webpack_require__(36)
  
  	// event listener directives
  	exports.on = __webpack_require__(39)
  	exports.model = __webpack_require__(40)
  
  	// logic control directives
  	exports.repeat = __webpack_require__(45)
  	exports['if'] = __webpack_require__(46)
  
  	// internal directives that should not be used directly
  	// but we still want to expose them for advanced usage.
  	exports._component = __webpack_require__(23)
  	exports._prop = __webpack_require__(16)
  
  
  /***/ },
  /* 26 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	module.exports = {
  
  	  bind: function () {
  	    this.attr = this.el.nodeType === 3
  	      ? 'data'
  	      : 'textContent'
  	  },
  
  	  update: function (value) {
  	    this.el[this.attr] = _.toString(value)
  	  }
  	}
  
  
  /***/ },
  /* 27 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var templateParser = __webpack_require__(22)
  
  	module.exports = {
  
  	  bind: function () {
  	    // a comment node means this is a binding for
  	    // {{{ inline unescaped html }}}
  	    if (this.el.nodeType === 8) {
  	      // hold nodes
  	      this.nodes = []
  	      // replace the placeholder with proper anchor
  	      this.anchor = _.createAnchor('v-html')
  	      _.replace(this.el, this.anchor)
  	    }
  	  },
  
  	  update: function (value) {
  	    value = _.toString(value)
  	    if (this.nodes) {
  	      this.swap(value)
  	    } else {
  	      this.el.innerHTML = value
  	    }
  	  },
  
  	  swap: function (value) {
  	    // remove old nodes
  	    var i = this.nodes.length
  	    while (i--) {
  	      _.remove(this.nodes[i])
  	    }
  	    // convert new value to a fragment
  	    // do not attempt to retrieve from id selector
  	    var frag = templateParser.parse(value, true, true)
  	    // save a reference to these nodes so we can remove later
  	    this.nodes = _.toArray(frag.childNodes)
  	    _.before(frag, this.anchor)
  	  }
  	}
  
  
  /***/ },
  /* 28 */
  /***/ function(module, exports) {
  
  	// xlink
  	var xlinkNS = 'http://www.w3.org/1999/xlink'
  	var xlinkRE = /^xlink:/
  	var inputProps = {
  	  value: 1,
  	  checked: 1,
  	  selected: 1
  	}
  
  	module.exports = {
  
  	  priority: 850,
  
  	  update: function (value) {
  	    if (this.arg) {
  	      this.setAttr(this.arg, value)
  	    } else if (typeof value === 'object') {
  	      this.objectHandler(value)
  	    }
  	  },
  
  	  objectHandler: function (value) {
  	    // cache object attrs so that only changed attrs
  	    // are actually updated.
  	    var cache = this.cache || (this.cache = {})
  	    var attr, val
  	    for (attr in cache) {
  	      if (!(attr in value)) {
  	        this.setAttr(attr, null)
  	        delete cache[attr]
  	      }
  	    }
  	    for (attr in value) {
  	      val = value[attr]
  	      if (val !== cache[attr]) {
  	        cache[attr] = val
  	        this.setAttr(attr, val)
  	      }
  	    }
  	  },
  
  	  setAttr: function (attr, value) {
  	    if (inputProps[attr] && attr in this.el) {
  	      if (!this.valueRemoved) {
  	        this.el.removeAttribute(attr)
  	        this.valueRemoved = true
  	      }
  	      this.el[attr] = value
  	    } else if (value != null && value !== false) {
  	      if (xlinkRE.test(attr)) {
  	        this.el.setAttributeNS(xlinkNS, attr, value)
  	      } else {
  	        this.el.setAttribute(attr, value)
  	      }
  	    } else {
  	      this.el.removeAttribute(attr)
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 29 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var transition = __webpack_require__(30)
  
  	module.exports = function (value) {
  	  var el = this.el
  	  transition.apply(el, value ? 1 : -1, function () {
  	    el.style.display = value ? '' : 'none'
  	  }, this.vm)
  	}
  
  
  /***/ },
  /* 30 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	/**
  	 * Append with transition.
  	 *
  	 * @param {Element} el
  	 * @param {Element} target
  	 * @param {Vue} vm
  	 * @param {Function} [cb]
  	 */
  
  	exports.append = function (el, target, vm, cb) {
  	  apply(el, 1, function () {
  	    target.appendChild(el)
  	  }, vm, cb)
  	}
  
  	/**
  	 * InsertBefore with transition.
  	 *
  	 * @param {Element} el
  	 * @param {Element} target
  	 * @param {Vue} vm
  	 * @param {Function} [cb]
  	 */
  
  	exports.before = function (el, target, vm, cb) {
  	  apply(el, 1, function () {
  	    _.before(el, target)
  	  }, vm, cb)
  	}
  
  	/**
  	 * Remove with transition.
  	 *
  	 * @param {Element} el
  	 * @param {Vue} vm
  	 * @param {Function} [cb]
  	 */
  
  	exports.remove = function (el, vm, cb) {
  	  apply(el, -1, function () {
  	    _.remove(el)
  	  }, vm, cb)
  	}
  
  	/**
  	 * Remove by appending to another parent with transition.
  	 * This is only used in block operations.
  	 *
  	 * @param {Element} el
  	 * @param {Element} target
  	 * @param {Vue} vm
  	 * @param {Function} [cb]
  	 */
  
  	exports.removeThenAppend = function (el, target, vm, cb) {
  	  apply(el, -1, function () {
  	    target.appendChild(el)
  	  }, vm, cb)
  	}
  
  	/**
  	 * Append the childNodes of a fragment to target.
  	 *
  	 * @param {DocumentFragment} block
  	 * @param {Node} target
  	 * @param {Vue} vm
  	 */
  
  	exports.blockAppend = function (block, target, vm) {
  	  var nodes = _.toArray(block.childNodes)
  	  for (var i = 0, l = nodes.length; i < l; i++) {
  	    exports.before(nodes[i], target, vm)
  	  }
  	}
  
  	/**
  	 * Remove a block of nodes between two edge nodes.
  	 *
  	 * @param {Node} start
  	 * @param {Node} end
  	 * @param {Vue} vm
  	 */
  
  	exports.blockRemove = function (start, end, vm) {
  	  var node = start.nextSibling
  	  var next
  	  while (node !== end) {
  	    next = node.nextSibling
  	    exports.remove(node, vm)
  	    node = next
  	  }
  	}
  
  	/**
  	 * Apply transitions with an operation callback.
  	 *
  	 * @param {Element} el
  	 * @param {Number} direction
  	 *                  1: enter
  	 *                 -1: leave
  	 * @param {Function} op - the actual DOM operation
  	 * @param {Vue} vm
  	 * @param {Function} [cb]
  	 */
  
  	var apply = exports.apply = function (el, direction, op, vm, cb) {
  	  var 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)
  	}
  
  
  /***/ },
  /* 31 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var addClass = _.addClass
  	var removeClass = _.removeClass
  
  	module.exports = {
  
  	  bind: function () {
  	    // interpolations like class="{{abc}}" are converted
  	    // to v-class, and we need to remove the raw,
  	    // uninterpolated className at binding time.
  	    var raw = this._descriptor._rawClass
  	    if (raw) {
  	      this.prevKeys = raw.trim().split(/\s+/)
  	    }
  	  },
  
  	  update: function (value) {
  	    if (this.arg) {
  	      // single toggle
  	      if (value) {
  	        addClass(this.el, this.arg)
  	      } else {
  	        removeClass(this.el, this.arg)
  	      }
  	    } else {
  	      if (value && typeof value === 'string') {
  	        this.handleObject(stringToObject(value))
  	      } else if (_.isPlainObject(value)) {
  	        this.handleObject(value)
  	      } else {
  	        this.cleanup()
  	      }
  	    }
  	  },
  
  	  handleObject: function (value) {
  	    this.cleanup(value)
  	    var keys = this.prevKeys = Object.keys(value)
  	    for (var i = 0, l = keys.length; i < l; i++) {
  	      var key = keys[i]
  	      if (value[key]) {
  	        addClass(this.el, key)
  	      } else {
  	        removeClass(this.el, key)
  	      }
  	    }
  	  },
  
  	  cleanup: function (value) {
  	    if (this.prevKeys) {
  	      var i = this.prevKeys.length
  	      while (i--) {
  	        var key = this.prevKeys[i]
  	        if (!value || !value.hasOwnProperty(key)) {
  	          removeClass(this.el, key)
  	        }
  	      }
  	    }
  	  }
  	}
  
  	function stringToObject (value) {
  	  var res = {}
  	  var keys = value.trim().split(/\s+/)
  	  var i = keys.length
  	  while (i--) {
  	    res[keys[i]] = true
  	  }
  	  return res
  	}
  
  
  /***/ },
  /* 32 */
  /***/ function(module, exports) {
  
  	module.exports = {
  
  	  isLiteral: true,
  
  	  bind: function () {
  	    this.vm.$$[this.expression] = this.el
  	  },
  
  	  unbind: function () {
  	    delete this.vm.$$[this.expression]
  	  }
  	}
  
  
  /***/ },
  /* 33 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	module.exports = {
  
  	  isLiteral: true,
  
  	  bind: function () {
  	    var vm = this.el.__vue__
  	    if (!vm) {
  	      ("development") !== 'production' && _.warn(
  	        'v-ref should only be used on a component root element.'
  	      )
  	      return
  	    }
  	    // If we get here, it means this is a `v-ref` on a
  	    // child, because parent scope `v-ref` is stripped in
  	    // `v-component` already. So we just record our own ref
  	    // here - it will overwrite parent ref in `v-component`,
  	    // if any.
  	    vm._refID = this.expression
  	  }
  	}
  
  
  /***/ },
  /* 34 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var config = __webpack_require__(5)
  
  	module.exports = {
  	  bind: function () {
  	    var el = this.el
  	    this.vm.$once('hook:compiled', function () {
  	      el.removeAttribute(config.prefix + 'cloak')
  	    })
  	  }
  	}
  
  
  /***/ },
  /* 35 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var prefixes = ['-webkit-', '-moz-', '-ms-']
  	var camelPrefixes = ['Webkit', 'Moz', 'ms']
  	var importantRE = /!important;?$/
  	var camelRE = /([a-z])([A-Z])/g
  	var testEl = null
  	var propCache = {}
  
  	module.exports = {
  
  	  deep: true,
  
  	  update: function (value) {
  	    if (this.arg) {
  	      this.setProp(this.arg, value)
  	    } else {
  	      if (typeof value === 'object') {
  	        this.objectHandler(value)
  	      } else {
  	        this.el.style.cssText = value
  	      }
  	    }
  	  },
  
  	  objectHandler: function (value) {
  	    // cache object styles so that only changed props
  	    // are actually updated.
  	    var cache = this.cache || (this.cache = {})
  	    var prop, val
  	    for (prop in cache) {
  	      if (!(prop in value)) {
  	        this.setProp(prop, null)
  	        delete cache[prop]
  	      }
  	    }
  	    for (prop in value) {
  	      val = value[prop]
  	      if (val !== cache[prop]) {
  	        cache[prop] = val
  	        this.setProp(prop, val)
  	      }
  	    }
  	  },
  
  	  setProp: function (prop, value) {
  	    prop = normalize(prop)
  	    if (!prop) return // unsupported prop
  	    // cast possible numbers/booleans into strings
  	    if (value != null) value += ''
  	    if (value) {
  	      var isImportant = importantRE.test(value)
  	        ? 'important'
  	        : ''
  	      if (isImportant) {
  	        value = value.replace(importantRE, '').trim()
  	      }
  	      this.el.style.setProperty(prop, value, isImportant)
  	    } else {
  	      this.el.style.removeProperty(prop)
  	    }
  	  }
  
  	}
  
  	/**
  	 * 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 = prop.replace(camelRE, '$1-$2').toLowerCase()
  	  var camel = _.camelize(prop)
  	  var upper = camel.charAt(0).toUpperCase() + camel.slice(1)
  	  if (!testEl) {
  	    testEl = document.createElement('div')
  	  }
  	  if (camel in testEl.style) {
  	    return prop
  	  }
  	  var i = prefixes.length
  	  var prefixed
  	  while (i--) {
  	    prefixed = camelPrefixes[i] + upper
  	    if (prefixed in testEl.style) {
  	      return prefixes[i] + prop
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 36 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var Transition = __webpack_require__(37)
  
  	module.exports = {
  
  	  priority: 1000,
  	  isLiteral: true,
  
  	  bind: function () {
  	    if (!this._isDynamicLiteral) {
  	      this.update(this.expression)
  	    }
  	  },
  
  	  update: function (id, oldId) {
  	    var el = this.el
  	    var vm = this.el.__vue__ || this.vm
  	    var hooks = _.resolveAsset(vm.$options, 'transitions', id)
  	    id = id || 'v'
  	    el.__v_trans = new Transition(el, id, hooks, vm)
  	    if (oldId) {
  	      _.removeClass(el, oldId + '-transition')
  	    }
  	    _.addClass(el, id + '-transition')
  	  }
  	}
  
  
  /***/ },
  /* 37 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var queue = __webpack_require__(38)
  	var addClass = _.addClass
  	var removeClass = _.removeClass
  	var transitionEndEvent = _.transitionEndEvent
  	var animationEndEvent = _.animationEndEvent
  	var transDurationProp = _.transitionProp + 'Duration'
  	var animDurationProp = _.animationProp + 'Duration'
  
  	var TYPE_TRANSITION = 1
  	var TYPE_ANIMATION = 2
  
  	var uid = 0
  
  	/**
  	 * 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 = uid++
  	  this.el = el
  	  this.enterClass = id + '-enter'
  	  this.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.typeCache = {}
  	  // bind
  	  var self = this
  	  ;['enterNextTick', 'enterDone', 'leaveNextTick', 'leaveDone']
  	    .forEach(function (m) {
  	      self[m] = _.bind(self[m], self)
  	    })
  	}
  
  	var p = 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.enter = function (op, cb) {
  	  this.cancelPending()
  	  this.callHook('beforeEnter')
  	  this.cb = cb
  	  addClass(this.el, this.enterClass)
  	  op()
  	  this.callHookWithCb('enter')
  	  this.cancel = this.hooks && this.hooks.enterCancelled
  	  queue.push(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.enterNextTick = function () {
  	  this.justEntered = true
  	  _.nextTick(function () {
  	    this.justEntered = false
  	  }, this)
  	  var type = this.getCssTransitionType(this.enterClass)
  	  var enterDone = this.enterDone
  	  if (type === TYPE_TRANSITION) {
  	    // trigger transition by removing enter class now
  	    removeClass(this.el, this.enterClass)
  	    this.setupCssCb(transitionEndEvent, enterDone)
  	  } else if (type === TYPE_ANIMATION) {
  	    this.setupCssCb(animationEndEvent, enterDone)
  	  } else if (!this.pendingJsCb) {
  	    enterDone()
  	  }
  	}
  
  	/**
  	 * The "cleanup" phase of an entering transition.
  	 */
  
  	p.enterDone = function () {
  	  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.leave = function (op, cb) {
  	  this.cancelPending()
  	  this.callHook('beforeLeave')
  	  this.op = op
  	  this.cb = cb
  	  addClass(this.el, this.leaveClass)
  	  this.callHookWithCb('leave')
  	  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 {
  	      queue.push(this.leaveNextTick)
  	    }
  	  }
  	}
  
  	/**
  	 * The "nextTick" phase of a leaving transition.
  	 */
  
  	p.leaveNextTick = function () {
  	  var type = this.getCssTransitionType(this.leaveClass)
  	  if (type) {
  	    var event = type === TYPE_TRANSITION
  	      ? transitionEndEvent
  	      : animationEndEvent
  	    this.setupCssCb(event, this.leaveDone)
  	  } else {
  	    this.leaveDone()
  	  }
  	}
  
  	/**
  	 * The "cleanup" phase of a leaving transition.
  	 */
  
  	p.leaveDone = function () {
  	  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.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.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.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.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)
  	  ) {
  	    return
  	  }
  	  var type = this.typeCache[className]
  	  if (type) return type
  	  var inlineStyles = this.el.style
  	  var computedStyles = window.getComputedStyle(this.el)
  	  var transDuration =
  	    inlineStyles[transDurationProp] ||
  	    computedStyles[transDurationProp]
  	  if (transDuration && transDuration !== '0s') {
  	    type = TYPE_TRANSITION
  	  } else {
  	    var 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.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)
  	}
  
  	module.exports = Transition
  
  
  /***/ },
  /* 38 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var queue = []
  	var queued = false
  
  	/**
  	 * Push a job into the queue.
  	 *
  	 * @param {Function} job
  	 */
  
  	exports.push = function (job) {
  	  queue.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.length; i++) {
  	    queue[i]()
  	  }
  	  queue = []
  	  queued = false
  	  // dummy return, so js linters don't complain about
  	  // unused variable f
  	  return f
  	}
  
  
  /***/ },
  /* 39 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	module.exports = {
  
  	  acceptStatement: true,
  	  priority: 700,
  
  	  bind: function () {
  	    // deal with iframes
  	    if (
  	      this.el.tagName === 'IFRAME' &&
  	      this.arg !== 'load'
  	    ) {
  	      var self = this
  	      this.iframeBind = function () {
  	        _.on(self.el.contentWindow, self.arg, self.handler)
  	      }
  	      this.on('load', this.iframeBind)
  	    }
  	  },
  
  	  update: function (handler) {
  	    if (typeof handler !== 'function') {
  	      ("development") !== 'production' && _.warn(
  	        'Directive v-on="' + this.arg + ': ' +
  	        this.expression + '" expects a function value, ' +
  	        'got ' + handler
  	      )
  	      return
  	    }
  	    this.reset()
  	    var vm = this.vm
  	    this.handler = function (e) {
  	      e.targetVM = vm
  	      vm.$event = e
  	      var res = handler(e)
  	      vm.$event = null
  	      return res
  	    }
  	    if (this.iframeBind) {
  	      this.iframeBind()
  	    } else {
  	      _.on(this.el, this.arg, this.handler)
  	    }
  	  },
  
  	  reset: function () {
  	    var el = this.iframeBind
  	      ? this.el.contentWindow
  	      : this.el
  	    if (this.handler) {
  	      _.off(el, this.arg, this.handler)
  	    }
  	  },
  
  	  unbind: function () {
  	    this.reset()
  	  }
  	}
  
  
  /***/ },
  /* 40 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	var handlers = {
  	  text: __webpack_require__(41),
  	  radio: __webpack_require__(42),
  	  select: __webpack_require__(43),
  	  checkbox: __webpack_require__(44)
  	}
  
  	module.exports = {
  
  	  priority: 800,
  	  twoWay: true,
  	  handlers: handlers,
  
  	  /**
  	   * Possible elements:
  	   *   <select>
  	   *   <textarea>
  	   *   <input type="*">
  	   *     - text
  	   *     - checkbox
  	   *     - radio
  	   *     - number
  	   *     - TODO: more types may be supplied as a plugin
  	   */
  
  	  bind: function () {
  	    // friendly warning...
  	    this.checkFilters()
  	    if (this.hasRead && !this.hasWrite) {
  	      ("development") !== 'production' && _.warn(
  	        'It seems you are using a read-only filter with ' +
  	        'v-model. You might want to use a two-way filter ' +
  	        'to ensure correct behavior.'
  	      )
  	    }
  	    var el = this.el
  	    var tag = el.tagName
  	    var handler
  	    if (tag === 'INPUT') {
  	      handler = handlers[el.type] || handlers.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
  	      )
  	      return
  	    }
  	    handler.bind.call(this)
  	    this.update = handler.update
  	    this.unbind = handler.unbind
  	  },
  
  	  /**
  	   * Check read/write filter stats.
  	   */
  
  	  checkFilters: function () {
  	    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
  	      }
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 41 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	module.exports = {
  
  	  bind: function () {
  	    var self = this
  	    var el = this.el
  	    var isRange = el.type === 'range'
  
  	    // check params
  	    // - lazy: update model on "change" instead of "input"
  	    var lazy = this._checkParam('lazy') != null
  	    // - number: cast value into number when updating model.
  	    var number = this._checkParam('number') != null
  	    // - debounce: debounce the input listener
  	    var debounce = parseInt(this._checkParam('debounce'), 10)
  
  	    // handle composition events.
  	    //   http://blog.evanyou.me/2014/01/03/composition-event/
  	    // 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.
  	        self.listener()
  	      })
  	    }
  
  	    // prevent messing with the input when user is typing,
  	    // and force update on blur.
  	    this.focused = false
  	    if (!isRange) {
  	      this.on('focus', function () {
  	        self.focused = true
  	      })
  	      this.on('blur', function () {
  	        self.focused = false
  	        self.listener()
  	      })
  	    }
  
  	    // Now attach the main listener
  	    this.listener = function () {
  	      if (composing) 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)
  	        }
  	      })
  	    }
  	    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) {
  	      jQuery(el).on('change', this.listener)
  	      if (!lazy) {
  	        jQuery(el).on('input', this.listener)
  	      }
  	    } else {
  	      this.on('change', this.listener)
  	      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._initValue = number
  	        ? _.toNumber(el.value)
  	        : el.value
  	    }
  	  },
  
  	  update: function (value) {
  	    this.el.value = _.toString(value)
  	  },
  
  	  unbind: function () {
  	    var el = this.el
  	    if (this.hasjQuery) {
  	      jQuery(el).off('change', this.listener)
  	      jQuery(el).off('input', this.listener)
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 42 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	module.exports = {
  
  	  bind: function () {
  	    var self = this
  	    var el = this.el
  	    var number = this._checkParam('number') != null
  	    var expression = this._checkParam('exp')
  
  	    this.getValue = function () {
  	      var val = el.value
  	      if (number) {
  	        val = _.toNumber(val)
  	      } else if (expression !== null) {
  	        val = self.vm.$eval(expression)
  	      }
  	      return val
  	    }
  
  	    this.on('change', function () {
  	      self.set(self.getValue())
  	    })
  
  	    if (el.checked) {
  	      this._initValue = this.getValue()
  	    }
  	  },
  
  	  update: function (value) {
  	    this.el.checked = _.looseEqual(value, this.getValue())
  	  }
  	}
  
  
  /***/ },
  /* 43 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var Watcher = __webpack_require__(17)
  	var dirParser = __webpack_require__(15)
  
  	module.exports = {
  
  	  bind: function () {
  	    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 options param
  	    var optionsParam = this._checkParam('options')
  	    if (optionsParam) {
  	      initOptions.call(this, optionsParam)
  	    }
  	    this.number = this._checkParam('number') != null
  	    this.multiple = el.hasAttribute('multiple')
  
  	    // attach listener
  	    this.on('change', function () {
  	      var value = getValue(el, self.multiple)
  	      value = self.number
  	        ? _.isArray(value)
  	          ? value.map(_.toNumber)
  	          : _.toNumber(value)
  	        : value
  	      self.set(value)
  	    })
  
  	    // check initial value (inline selected attribute)
  	    checkInitialValue.call(this)
  
  	    // 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', this.forceUpdate)
  	  },
  
  	  update: function (value) {
  	    var el = this.el
  	    el.selectedIndex = -1
  	    if (value == null) {
  	      if (this.defaultOption) {
  	        this.defaultOption.selected = true
  	      }
  	      return
  	    }
  	    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(value, val) > -1
  	        : _.looseEqual(value, val)
  	      /* eslint-enable eqeqeq */
  	    }
  	  },
  
  	  unbind: function () {
  	    this.vm.$off('hook:attached', this.forceUpdate)
  	    if (this.optionWatcher) {
  	      this.optionWatcher.teardown()
  	    }
  	  }
  	}
  
  	/**
  	 * Initialize the option list from the param.
  	 *
  	 * @param {String} expression
  	 */
  
  	function initOptions (expression) {
  	  var self = this
  	  var el = self.el
  	  var defaultOption = self.defaultOption = self.el.options[0]
  	  var descriptor = dirParser.parse(expression)[0]
  	  function optionUpdateWatcher (value) {
  	    if (_.isArray(value)) {
  	      // clear old options.
  	      // cannot reset innerHTML here because IE family get
  	      // confused during compilation.
  	      var i = el.options.length
  	      while (i--) {
  	        var option = el.options[i]
  	        if (option !== defaultOption) {
  	          el.removeChild(option)
  	        }
  	      }
  	      buildOptions(el, value)
  	      self.forceUpdate()
  	    } else {
  	      ("development") !== 'production' && _.warn(
  	        'Invalid options value for v-model: ' + value
  	      )
  	    }
  	  }
  	  this.optionWatcher = new Watcher(
  	    this.vm,
  	    descriptor.expression,
  	    optionUpdateWatcher,
  	    {
  	      deep: true,
  	      filters: descriptor.filters
  	    }
  	  )
  	  // update with initial value
  	  optionUpdateWatcher(this.optionWatcher.value)
  	}
  
  	/**
  	 * Build up option elements. IE9 doesn't create options
  	 * when setting innerHTML on <select> elements, so we have
  	 * to use DOM API here.
  	 *
  	 * @param {Element} parent - a <select> or an <optgroup>
  	 * @param {Array} options
  	 */
  
  	function buildOptions (parent, options) {
  	  var op, el
  	  for (var i = 0, l = options.length; i < l; i++) {
  	    op = options[i]
  	    if (!op.options) {
  	      el = document.createElement('option')
  	      if (typeof op === 'string') {
  	        el.text = el.value = op
  	      } else {
  	        if (op.value != null && !_.isObject(op.value)) {
  	          el.value = op.value
  	        }
  	        // object values gets serialized when set as value,
  	        // so we store the raw value as a different property
  	        el._value = op.value
  	        el.text = op.text || ''
  	        if (op.disabled) {
  	          el.disabled = true
  	        }
  	      }
  	    } else {
  	      el = document.createElement('optgroup')
  	      el.label = op.label
  	      buildOptions(el, op.options)
  	    }
  	    parent.appendChild(el)
  	  }
  	}
  
  	/**
  	 * Check the initial value for selected options.
  	 */
  
  	function checkInitialValue () {
  	  var initValue
  	  var options = this.el.options
  	  for (var i = 0, l = options.length; i < l; i++) {
  	    if (options[i].hasAttribute('selected')) {
  	      if (this.multiple) {
  	        (initValue || (initValue = []))
  	          .push(options[i].value)
  	      } else {
  	        initValue = options[i].value
  	      }
  	    }
  	  }
  	  if (typeof initValue !== 'undefined') {
  	    this._initValue = this.number
  	      ? _.toNumber(initValue)
  	      : initValue
  	  }
  	}
  
  	/**
  	 * Get select value
  	 *
  	 * @param {SelectElement} el
  	 * @param {Boolean} multi
  	 * @return {Array|*}
  	 */
  
  	function getValue (el, multi) {
  	  var res = multi ? [] : null
  	  var op, val
  	  for (var i = 0, l = el.options.length; i < l; i++) {
  	    op = el.options[i]
  	    if (op.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 (arr, val) {
  	  var i = arr.length
  	  while (i--) {
  	    if (_.looseEqual(arr[i], val)) {
  	      return i
  	    }
  	  }
  	  return -1
  	}
  
  
  /***/ },
  /* 44 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	module.exports = {
  
  	  bind: function () {
  	    var self = this
  	    var el = this.el
  	    var trueExp = this._checkParam('true-exp')
  	    var falseExp = this._checkParam('false-exp')
  
  	    this._matchValue = function (value) {
  	      if (trueExp !== null) {
  	        return _.looseEqual(value, self.vm.$eval(trueExp))
  	      } else {
  	        return !!value
  	      }
  	    }
  
  	    function getValue () {
  	      var val = el.checked
  	      if (val && trueExp !== null) {
  	        val = self.vm.$eval(trueExp)
  	      }
  	      if (!val && falseExp !== null) {
  	        val = self.vm.$eval(falseExp)
  	      }
  	      return val
  	    }
  
  	    this.on('change', function () {
  	      self.set(getValue())
  	    })
  
  	    if (el.checked) {
  	      this._initValue = getValue()
  	    }
  	  },
  
  	  update: function (value) {
  	    this.el.checked = this._matchValue(value)
  	  }
  	}
  
  
  /***/ },
  /* 45 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  	var isObject = _.isObject
  	var isPlainObject = _.isPlainObject
  	var textParser = __webpack_require__(13)
  	var expParser = __webpack_require__(19)
  	var templateParser = __webpack_require__(22)
  	var compiler = __webpack_require__(10)
  	var uid = 0
  
  	// async component resolution states
  	var UNRESOLVED = 0
  	var PENDING = 1
  	var RESOLVED = 2
  	var ABORTED = 3
  
  	module.exports = {
  
  	  /**
  	   * Setup.
  	   */
  
  	  bind: function () {
  	    // support for item in array syntax
  	    var inMatch = this.expression.match(/(.*) in (.*)/)
  	    if (inMatch) {
  	      this.arg = inMatch[1]
  	      this._watcherExp = inMatch[2]
  	    }
  	    // uid as a cache identifier
  	    this.id = '__v_repeat_' + (++uid)
  
  	    // setup anchor nodes
  	    this.start = _.createAnchor('v-repeat-start')
  	    this.end = _.createAnchor('v-repeat-end')
  	    _.replace(this.el, this.end)
  	    _.before(this.start, this.end)
  
  	    // check if this is a block repeat
  	    this.template = _.isTemplate(this.el)
  	      ? templateParser.parse(this.el, true)
  	      : this.el
  
  	    // check for trackby param
  	    this.idKey = this._checkParam('track-by')
  	    // check for transition stagger
  	    var stagger = +this._checkParam('stagger')
  	    this.enterStagger = +this._checkParam('enter-stagger') || stagger
  	    this.leaveStagger = +this._checkParam('leave-stagger') || stagger
  
  	    // check for v-ref/v-el
  	    this.refID = this._checkParam(config.prefix + 'ref')
  	    this.elID = this._checkParam(config.prefix + 'el')
  
  	    // check other directives that need to be handled
  	    // at v-repeat level
  	    this.checkIf()
  	    this.checkComponent()
  
  	    // create cache object
  	    this.cache = Object.create(null)
  
  	    // some helpful tips...
  	    /* istanbul ignore if */
  	    if (
  	      ("development") !== 'production' &&
  	      this.el.tagName === 'OPTION'
  	    ) {
  	      _.warn(
  	        'Don\'t use v-repeat for v-model options; ' +
  	        'use the `options` param instead: ' +
  	        'http://vuejs.org/guide/forms.html#Dynamic_Select_Options'
  	      )
  	    }
  	  },
  
  	  /**
  	   * Warn against v-if usage.
  	   */
  
  	  checkIf: function () {
  	    if (_.attr(this.el, 'if') !== null) {
  	      ("development") !== 'production' && _.warn(
  	        'Don\'t use v-if with v-repeat. ' +
  	        'Use v-show or the "filterBy" filter instead.'
  	      )
  	    }
  	  },
  
  	  /**
  	   * Check the component constructor to use for repeated
  	   * instances. If static we resolve it now, otherwise it
  	   * needs to be resolved at build time with actual data.
  	   */
  
  	  checkComponent: function () {
  	    this.componentState = UNRESOLVED
  	    var options = this.vm.$options
  	    var id = _.checkComponent(this.el, options)
  	    if (!id) {
  	      // default constructor
  	      this.Component = _.Vue
  	      // inline repeats should inherit
  	      this.inline = true
  	      // important: transclude with no options, just
  	      // to ensure block start and block end
  	      this.template = compiler.transclude(this.template)
  	      var copy = _.extend({}, options)
  	      copy._asComponent = false
  	      this._linkFn = compiler.compile(this.template, copy)
  	    } else {
  	      this.Component = null
  	      this.asComponent = true
  	      // check inline-template
  	      if (this._checkParam('inline-template') !== null) {
  	        // extract inline template as a DocumentFragment
  	        this.inlineTemplate = _.extractContent(this.el, true)
  	      }
  	      var tokens = textParser.parse(id)
  	      if (tokens) {
  	        // dynamic component to be resolved later
  	        var componentExp = textParser.tokensToExp(tokens)
  	        this.componentGetter = expParser.parse(componentExp).get
  	      } else {
  	        // static
  	        this.componentId = id
  	        this.pendingData = null
  	      }
  	    }
  	  },
  
  	  resolveComponent: function () {
  	    this.componentState = PENDING
  	    this.vm._resolveComponent(this.componentId, _.bind(function (Component) {
  	      if (this.componentState === ABORTED) {
  	        return
  	      }
  	      this.Component = Component
  	      this.componentState = RESOLVED
  	      this.realUpdate(this.pendingData)
  	      this.pendingData = null
  	    }, this))
  	  },
  
  	  /**
  	   * Resolve a dynamic component to use for an instance.
  	   * The tricky part here is that there could be dynamic
  	   * components depending on instance data.
  	   *
  	   * @param {Object} data
  	   * @param {Object} meta
  	   * @return {Function}
  	   */
  
  	  resolveDynamicComponent: function (data, meta) {
  	    // create a temporary context object and copy data
  	    // and meta properties onto it.
  	    // use _.define to avoid accidentally overwriting scope
  	    // properties.
  	    var context = Object.create(this.vm)
  	    var key
  	    for (key in data) {
  	      _.define(context, key, data[key])
  	    }
  	    for (key in meta) {
  	      _.define(context, key, meta[key])
  	    }
  	    var id = this.componentGetter.call(context, context)
  	    var Component = _.resolveAsset(this.vm.$options, 'components', id)
  	    if (true) {
  	      _.assertAsset(Component, 'component', id)
  	    }
  	    if (!Component.options) {
  	      ("development") !== 'production' && _.warn(
  	        'Async resolution is not supported for v-repeat ' +
  	        '+ dynamic component. (component: ' + id + ')'
  	      )
  	      return _.Vue
  	    }
  	    return Component
  	  },
  
  	  /**
  	   * Update.
  	   * This is called whenever the Array mutates. If we have
  	   * a component, we might need to wait for it to resolve
  	   * asynchronously.
  	   *
  	   * @param {Array|Number|String} data
  	   */
  
  	  update: function (data) {
  	    if (this.componentId) {
  	      var state = this.componentState
  	      if (state === UNRESOLVED) {
  	        this.pendingData = data
  	        // once resolved, it will call realUpdate
  	        this.resolveComponent()
  	      } else if (state === PENDING) {
  	        this.pendingData = data
  	      } else if (state === RESOLVED) {
  	        this.realUpdate(data)
  	      }
  	    } else {
  	      this.realUpdate(data)
  	    }
  	  },
  
  	  /**
  	   * The real update that actually modifies the DOM.
  	   *
  	   * @param {Array|Number|String} data
  	   */
  
  	  realUpdate: function (data) {
  	    this.vms = this.diff(data, this.vms)
  	    // update v-ref
  	    if (this.refID) {
  	      this.vm.$[this.refID] = this.converted
  	        ? toRefObject(this.vms)
  	        : this.vms
  	    }
  	    if (this.elID) {
  	      this.vm.$$[this.elID] = this.vms.map(function (vm) {
  	        return vm.$el
  	      })
  	    }
  	  },
  
  	  /**
  	   * Diff, based on new data and old data, determine the
  	   * minimum amount of DOM manipulations needed to make the
  	   * DOM reflect the new data Array.
  	   *
  	   * The algorithm diffs the new data Array by storing a
  	   * hidden reference to an owner vm instance on previously
  	   * seen data. This allows us to achieve O(n) which is
  	   * better than a levenshtein distance based algorithm,
  	   * which is O(m * n).
  	   *
  	   * @param {Array} data
  	   * @param {Array} oldVms
  	   * @return {Array}
  	   */
  
  	  diff: function (data, oldVms) {
  	    var idKey = this.idKey
  	    var converted = this.converted
  	    var start = this.start
  	    var end = this.end
  	    var inDoc = _.inDoc(start)
  	    var alias = this.arg
  	    var init = !oldVms
  	    var vms = new Array(data.length)
  	    var obj, raw, vm, i, l, primitive
  	    // First pass, go through the new Array and fill up
  	    // the new vms array. If a piece of data has a cached
  	    // instance for it, we reuse it. Otherwise build a new
  	    // instance.
  	    for (i = 0, l = data.length; i < l; i++) {
  	      obj = data[i]
  	      raw = converted ? obj.$value : obj
  	      primitive = !isObject(raw)
  	      vm = !init && this.getVm(raw, i, converted ? obj.$key : null)
  	      if (vm) { // reusable instance
  	        vm._reused = true
  	        vm.$index = i // update $index
  	        // update data for track-by or object repeat,
  	        // since in these two cases the data is replaced
  	        // rather than mutated.
  	        if (idKey || converted || primitive) {
  	          if (alias) {
  	            vm[alias] = raw
  	          } else if (_.isPlainObject(raw)) {
  	            vm.$data = raw
  	          } else {
  	            vm.$value = raw
  	          }
  	        }
  	      } else { // new instance
  	        vm = this.build(obj, i, true)
  	        vm._reused = false
  	      }
  	      vms[i] = vm
  	      // insert if this is first run
  	      if (init) {
  	        vm.$before(end)
  	      }
  	    }
  	    // if this is the first run, we're done.
  	    if (init) {
  	      return vms
  	    }
  	    // Second pass, go through the old vm instances and
  	    // destroy those who are not reused (and remove them
  	    // from cache)
  	    var removalIndex = 0
  	    var totalRemoved = oldVms.length - vms.length
  	    for (i = 0, l = oldVms.length; i < l; i++) {
  	      vm = oldVms[i]
  	      if (!vm._reused) {
  	        this.uncacheVm(vm)
  	        vm.$destroy(false, true) // defer cleanup until removal
  	        this.remove(vm, removalIndex++, totalRemoved, inDoc)
  	      }
  	    }
  	    // final pass, move/insert new instances into the
  	    // right place.
  	    var targetPrev, prevEl, currentPrev
  	    var insertionIndex = 0
  	    for (i = 0, l = vms.length; i < l; i++) {
  	      vm = vms[i]
  	      // this is the vm that we should be after
  	      targetPrev = vms[i - 1]
  	      prevEl = targetPrev
  	        ? targetPrev._staggerCb
  	          ? targetPrev._staggerAnchor
  	          : targetPrev._fragmentEnd || targetPrev.$el
  	        : start
  	      if (vm._reused && !vm._staggerCb) {
  	        currentPrev = findPrevVm(vm, start, this.id)
  	        if (currentPrev !== targetPrev) {
  	          this.move(vm, prevEl)
  	        }
  	      } else {
  	        // new instance, or still in stagger.
  	        // insert with updated stagger index.
  	        this.insert(vm, insertionIndex++, prevEl, inDoc)
  	      }
  	      vm._reused = false
  	    }
  	    return vms
  	  },
  
  	  /**
  	   * Build a new instance and cache it.
  	   *
  	   * @param {Object} data
  	   * @param {Number} index
  	   * @param {Boolean} needCache
  	   */
  
  	  build: function (data, index, needCache) {
  	    var meta = { $index: index }
  	    if (this.converted) {
  	      meta.$key = data.$key
  	    }
  	    var raw = this.converted ? data.$value : data
  	    var alias = this.arg
  	    if (alias) {
  	      data = {}
  	      data[alias] = raw
  	    } else if (!isPlainObject(raw)) {
  	      // non-object values
  	      data = {}
  	      meta.$value = raw
  	    } else {
  	      // default
  	      data = raw
  	    }
  	    // resolve constructor
  	    var Component = this.Component || this.resolveDynamicComponent(data, meta)
  	    var parent = this._host || this.vm
  	    var vm = parent.$addChild({
  	      el: templateParser.clone(this.template),
  	      data: data,
  	      inherit: this.inline,
  	      template: this.inlineTemplate,
  	      // repeater meta, e.g. $index, $key
  	      _meta: meta,
  	      // mark this as an inline-repeat instance
  	      _repeat: this.inline,
  	      // is this a component?
  	      _asComponent: this.asComponent,
  	      // linker cachable if no inline-template
  	      _linkerCachable: !this.inlineTemplate && Component !== _.Vue,
  	      // pre-compiled linker for simple repeats
  	      _linkFn: this._linkFn,
  	      // identifier, shows that this vm belongs to this collection
  	      _repeatId: this.id,
  	      // transclusion content owner
  	      _context: this.vm
  	    }, Component)
  	    // cache instance
  	    if (needCache) {
  	      this.cacheVm(raw, vm, index, this.converted ? meta.$key : null)
  	    }
  	    // sync back changes for two-way bindings of primitive values
  	    var dir = this
  	    if (this.rawType === 'object' && isPrimitive(raw)) {
  	      vm.$watch(alias || '$value', function (val) {
  	        if (dir.filters) {
  	          ("development") !== 'production' && _.warn(
  	            'You seem to be mutating the $value reference of ' +
  	            'a v-repeat instance (likely through v-model) ' +
  	            'and filtering the v-repeat at the same time. ' +
  	            'This will not work properly with an Array of ' +
  	            'primitive values. Please use an Array of ' +
  	            'Objects instead.'
  	          )
  	        }
  	        dir._withLock(function () {
  	          if (dir.converted) {
  	            dir.rawValue[vm.$key] = val
  	          } else {
  	            dir.rawValue.$set(vm.$index, val)
  	          }
  	        })
  	      })
  	    }
  	    return vm
  	  },
  
  	  /**
  	   * Unbind, teardown everything
  	   */
  
  	  unbind: function () {
  	    this.componentState = ABORTED
  	    if (this.refID) {
  	      this.vm.$[this.refID] = null
  	    }
  	    if (this.vms) {
  	      var i = this.vms.length
  	      var vm
  	      while (i--) {
  	        vm = this.vms[i]
  	        this.uncacheVm(vm)
  	        vm.$destroy()
  	      }
  	    }
  	  },
  
  	  /**
  	   * Cache a vm instance based on its data.
  	   *
  	   * If the data is an object, we save the vm's reference on
  	   * the data object as a hidden property. Otherwise we
  	   * cache them in an object and for each primitive value
  	   * there is an array in case there are duplicates.
  	   *
  	   * @param {Object} data
  	   * @param {Vue} vm
  	   * @param {Number} index
  	   * @param {String} [key]
  	   */
  
  	  cacheVm: function (data, vm, index, key) {
  	    var idKey = this.idKey
  	    var cache = this.cache
  	    var primitive = !isObject(data)
  	    var id
  	    if (key || idKey || primitive) {
  	      id = idKey
  	        ? idKey === '$index'
  	          ? index
  	          : data[idKey]
  	        : (key || index)
  	      if (!cache[id]) {
  	        cache[id] = vm
  	      } else if (!primitive && idKey !== '$index') {
  	        ("development") !== 'production' && _.warn(
  	          'Duplicate track-by key in v-repeat: ' + id
  	        )
  	      }
  	    } else {
  	      id = this.id
  	      if (data.hasOwnProperty(id)) {
  	        if (data[id] === null) {
  	          data[id] = vm
  	        } else {
  	          ("development") !== 'production' && _.warn(
  	            'Duplicate objects are not supported in v-repeat ' +
  	            'when using components or transitions.'
  	          )
  	        }
  	      } else {
  	        _.define(data, id, vm)
  	      }
  	    }
  	    vm._raw = data
  	  },
  
  	  /**
  	   * Try to get a cached instance from a piece of data.
  	   *
  	   * @param {Object} data
  	   * @param {Number} index
  	   * @param {String} [key]
  	   * @return {Vue|undefined}
  	   */
  
  	  getVm: function (data, index, key) {
  	    var idKey = this.idKey
  	    var primitive = !isObject(data)
  	    if (key || idKey || primitive) {
  	      var id = idKey
  	        ? idKey === '$index'
  	          ? index
  	          : data[idKey]
  	        : (key || index)
  	      return this.cache[id]
  	    } else {
  	      return data[this.id]
  	    }
  	  },
  
  	  /**
  	   * Delete a cached vm instance.
  	   *
  	   * @param {Vue} vm
  	   */
  
  	  uncacheVm: function (vm) {
  	    var data = vm._raw
  	    var idKey = this.idKey
  	    var index = vm.$index
  	    // fix #948: avoid accidentally fall through to
  	    // a parent repeater which happens to have $key.
  	    var key = vm.hasOwnProperty('$key') && vm.$key
  	    var primitive = !isObject(data)
  	    if (idKey || key || primitive) {
  	      var id = idKey
  	        ? idKey === '$index'
  	          ? index
  	          : data[idKey]
  	        : (key || index)
  	      this.cache[id] = null
  	    } else {
  	      data[this.id] = null
  	      vm._raw = null
  	    }
  	  },
  
  	  /**
  	   * Insert an instance.
  	   *
  	   * @param {Vue} vm
  	   * @param {Number} index
  	   * @param {Node} prevEl
  	   * @param {Boolean} inDoc
  	   */
  
  	  insert: function (vm, index, prevEl, inDoc) {
  	    if (vm._staggerCb) {
  	      vm._staggerCb.cancel()
  	      vm._staggerCb = null
  	    }
  	    var staggerAmount = this.getStagger(vm, index, null, 'enter')
  	    if (inDoc && 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 = vm._staggerAnchor
  	      if (!anchor) {
  	        anchor = vm._staggerAnchor = _.createAnchor('stagger-anchor')
  	        anchor.__vue__ = vm
  	      }
  	      _.after(anchor, prevEl)
  	      var op = vm._staggerCb = _.cancellable(function () {
  	        vm._staggerCb = null
  	        vm.$before(anchor)
  	        _.remove(anchor)
  	      })
  	      setTimeout(op, staggerAmount)
  	    } else {
  	      vm.$after(prevEl)
  	    }
  	  },
  
  	  /**
  	   * Move an already inserted instance.
  	   *
  	   * @param {Vue} vm
  	   * @param {Node} prevEl
  	   */
  
  	  move: function (vm, prevEl) {
  	    vm.$after(prevEl, null, false)
  	  },
  
  	  /**
  	   * Remove an instance.
  	   *
  	   * @param {Vue} vm
  	   * @param {Number} index
  	   * @param {Boolean} inDoc
  	   */
  
  	  remove: function (vm, index, total, inDoc) {
  	    if (vm._staggerCb) {
  	      vm._staggerCb.cancel()
  	      vm._staggerCb = null
  	      // it's not possible for the same vm to be removed
  	      // twice, so if we have a pending stagger callback,
  	      // it means this vm 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(vm, index, total, 'leave')
  	    if (inDoc && staggerAmount) {
  	      var op = vm._staggerCb = _.cancellable(function () {
  	        vm._staggerCb = null
  	        remove()
  	      })
  	      setTimeout(op, staggerAmount)
  	    } else {
  	      remove()
  	    }
  	    function remove () {
  	      vm.$remove(function () {
  	        vm._cleanup()
  	      })
  	    }
  	  },
  
  	  /**
  	   * Get the stagger amount for an insertion/removal.
  	   *
  	   * @param {Vue} vm
  	   * @param {Number} index
  	   * @param {String} type
  	   * @param {Number} total
  	   */
  
  	  getStagger: function (vm, index, total, type) {
  	    type = type + 'Stagger'
  	    var transition = vm.$el.__v_trans
  	    var hooks = transition && transition.hooks
  	    var hook = hooks && (hooks[type] || hooks.stagger)
  	    return hook
  	      ? hook.call(vm, index, total)
  	      : index * this[type]
  	  },
  
  	  /**
  	   * Pre-process the value before piping it through the
  	   * filters, and convert non-Array objects to arrays.
  	   *
  	   * This function will be bound to this directive instance
  	   * and passed into the watcher.
  	   *
  	   * @param {*} value
  	   * @return {Array}
  	   * @private
  	   */
  
  	  _preProcess: function (value) {
  	    // regardless of type, store the un-filtered raw value.
  	    this.rawValue = value
  	    var type = this.rawType = typeof value
  	    if (!isPlainObject(value)) {
  	      this.converted = false
  	      if (type === 'number') {
  	        value = range(value)
  	      } else if (type === 'string') {
  	        value = _.toArray(value)
  	      }
  	      return value || []
  	    } else {
  	      // convert plain object to array.
  	      var keys = Object.keys(value)
  	      var i = keys.length
  	      var res = new Array(i)
  	      var key
  	      while (i--) {
  	        key = keys[i]
  	        res[i] = {
  	          $key: key,
  	          $value: value[key]
  	        }
  	      }
  	      this.converted = true
  	      return res
  	    }
  	  }
  	}
  
  	/**
  	 * Helper to find the previous element that is an instance
  	 * root node. This is necessary because a destroyed vm's
  	 * element could still be lingering in the DOM before its
  	 * leaving transition finishes, but its __vue__ reference
  	 * should have been removed so we can skip them.
  	 *
  	 * If this is a block repeat, we want to make sure we only
  	 * return vm that is bound to this v-repeat. (see #929)
  	 *
  	 * @param {Vue} vm
  	 * @param {Comment|Text} anchor
  	 * @return {Vue}
  	 */
  
  	function findPrevVm (vm, anchor, id) {
  	  var el = vm.$el.previousSibling
  	  /* istanbul ignore if */
  	  if (!el) return
  	  while (
  	    (!el.__vue__ || el.__vue__.$options._repeatId !== id) &&
  	    el !== anchor
  	  ) {
  	    el = el.previousSibling
  	  }
  	  return el.__vue__
  	}
  
  	/**
  	 * Create a range array from given number.
  	 *
  	 * @param {Number} n
  	 * @return {Array}
  	 */
  
  	function range (n) {
  	  var i = -1
  	  var ret = new Array(n)
  	  while (++i < n) {
  	    ret[i] = i
  	  }
  	  return ret
  	}
  
  	/**
  	 * Convert a vms array to an object ref for v-ref on an
  	 * Object value.
  	 *
  	 * @param {Array} vms
  	 * @return {Object}
  	 */
  
  	function toRefObject (vms) {
  	  var ref = {}
  	  for (var i = 0, l = vms.length; i < l; i++) {
  	    ref[vms[i].$key] = vms[i]
  	  }
  	  return ref
  	}
  
  	/**
  	 * Check if a value is a primitive one:
  	 * String, Number, Boolean, null or undefined.
  	 *
  	 * @param {*} value
  	 * @return {Boolean}
  	 */
  
  	function isPrimitive (value) {
  	  var type = typeof value
  	  return value == null ||
  	    type === 'string' ||
  	    type === 'number' ||
  	    type === 'boolean'
  	}
  
  
  /***/ },
  /* 46 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var compiler = __webpack_require__(10)
  	var templateParser = __webpack_require__(22)
  	var transition = __webpack_require__(30)
  	var Cache = __webpack_require__(14)
  	var cache = new Cache(1000)
  
  	module.exports = {
  
  	  bind: function () {
  	    var el = this.el
  	    if (!el.__vue__) {
  	      this.start = _.createAnchor('v-if-start')
  	      this.end = _.createAnchor('v-if-end')
  	      _.replace(el, this.end)
  	      _.before(this.start, this.end)
  	      if (_.isTemplate(el)) {
  	        this.template = templateParser.parse(el, true)
  	      } else {
  	        this.template = document.createDocumentFragment()
  	        this.template.appendChild(templateParser.clone(el))
  	      }
  	      // compile the nested partial
  	      var cacheId = (this.vm.constructor.cid || '') + el.outerHTML
  	      this.linker = cache.get(cacheId)
  	      if (!this.linker) {
  	        this.linker = compiler.compile(
  	          this.template,
  	          this.vm.$options,
  	          true // partial
  	        )
  	        cache.put(cacheId, this.linker)
  	      }
  	    } else {
  	      ("development") !== 'production' && _.warn(
  	        'v-if="' + this.expression + '" cannot be ' +
  	        'used on an instance root element.'
  	      )
  	      this.invalid = true
  	    }
  	  },
  
  	  update: function (value) {
  	    if (this.invalid) return
  	    if (value) {
  	      // avoid duplicate compiles, since update() can be
  	      // called with different truthy values
  	      if (!this.unlink) {
  	        this.link(
  	          templateParser.clone(this.template),
  	          this.linker
  	        )
  	      }
  	    } else {
  	      this.teardown()
  	    }
  	  },
  
  	  link: function (frag, linker) {
  	    var vm = this.vm
  	    this.unlink = linker(vm, frag, this._host /* important */)
  	    transition.blockAppend(frag, this.end, vm)
  	    // call attached for all the child components created
  	    // during the compilation
  	    if (_.inDoc(vm.$el)) {
  	      var children = this.getContainedComponents()
  	      if (children) children.forEach(callAttach)
  	    }
  	  },
  
  	  teardown: function () {
  	    if (!this.unlink) return
  	    // collect children beforehand
  	    var children
  	    if (_.inDoc(this.vm.$el)) {
  	      children = this.getContainedComponents()
  	    }
  	    transition.blockRemove(this.start, this.end, this.vm)
  	    if (children) children.forEach(callDetach)
  	    this.unlink()
  	    this.unlink = null
  	  },
  
  	  getContainedComponents: function () {
  	    var vm = this.vm
  	    var start = this.start.nextSibling
  	    var end = this.end
  
  	    function contains (c) {
  	      var cur = start
  	      var next
  	      while (next !== end) {
  	        next = cur.nextSibling
  	        if (
  	          cur === c.$el ||
  	          cur.contains && cur.contains(c.$el)
  	        ) {
  	          return true
  	        }
  	        cur = next
  	      }
  	      return false
  	    }
  
  	    return vm.$children.length &&
  	      vm.$children.filter(contains)
  	  },
  
  	  unbind: function () {
  	    if (this.unlink) this.unlink()
  	  }
  
  	}
  
  	function callAttach (child) {
  	  if (!child._isAttached) {
  	    child._callHook('attached')
  	  }
  	}
  
  	function callDetach (child) {
  	  if (child._isAttached) {
  	    child._callHook('detached')
  	  }
  	}
  
  
  /***/ },
  /* 47 */
  /***/ function(module, exports, __webpack_require__) {
  
  	exports.content = __webpack_require__(48)
  	exports.partial = __webpack_require__(49)
  
  
  /***/ },
  /* 48 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var clone = __webpack_require__(22).clone
  
  	// This is the elementDirective that handles <content>
  	// transclusions. It relies on the raw content of an
  	// instance being stored as `$options._content` during
  	// the transclude phase.
  
  	module.exports = {
  
  	  bind: function () {
  	    var vm = this.vm
  	    var host = vm
  	    // we need find the content context, which is the
  	    // closest non-inline-repeater instance.
  	    while (host.$options._repeat) {
  	      host = host.$parent
  	    }
  	    var raw = host.$options._content
  	    var content
  	    if (!raw) {
  	      this.fallback()
  	      return
  	    }
  	    var context = host._context
  	    var selector = this._checkParam('select')
  	    if (!selector) {
  	      // Default content
  	      var self = this
  	      var compileDefaultContent = function () {
  	        self.compile(
  	          extractFragment(raw.childNodes, raw, true),
  	          context,
  	          vm
  	        )
  	      }
  	      if (!host._isCompiled) {
  	        // defer until the end of instance compilation,
  	        // because the default outlet must wait until all
  	        // other possible outlets with selectors have picked
  	        // out their contents.
  	        host.$once('hook:compiled', compileDefaultContent)
  	      } else {
  	        compileDefaultContent()
  	      }
  	    } else {
  	      // select content
  	      var nodes = raw.querySelectorAll(selector)
  	      if (nodes.length) {
  	        content = extractFragment(nodes, raw)
  	        if (content.hasChildNodes()) {
  	          this.compile(content, context, vm)
  	        } else {
  	          this.fallback()
  	        }
  	      } else {
  	        this.fallback()
  	      }
  	    }
  	  },
  
  	  fallback: function () {
  	    this.compile(_.extractContent(this.el, true), this.vm)
  	  },
  
  	  compile: function (content, context, host) {
  	    if (content && context) {
  	      this.unlink = context.$compile(content, host)
  	    }
  	    if (content) {
  	      _.replace(this.el, content)
  	    } else {
  	      _.remove(this.el)
  	    }
  	  },
  
  	  unbind: function () {
  	    if (this.unlink) {
  	      this.unlink()
  	    }
  	  }
  	}
  
  	/**
  	 * Extract qualified content nodes from a node list.
  	 *
  	 * @param {NodeList} nodes
  	 * @param {Element} parent
  	 * @param {Boolean} main
  	 * @return {DocumentFragment}
  	 */
  
  	function extractFragment (nodes, parent, main) {
  	  var frag = document.createDocumentFragment()
  	  for (var i = 0, l = nodes.length; i < l; i++) {
  	    var node = nodes[i]
  	    // if this is the main outlet, we want to skip all
  	    // previously selected nodes;
  	    // otherwise, we want to mark the node as selected.
  	    // clone the node so the original raw content remains
  	    // intact. this ensures proper re-compilation in cases
  	    // where the outlet is inside a conditional block
  	    if (main && !node.__v_selected) {
  	      frag.appendChild(clone(node))
  	    } else if (!main && node.parentNode === parent) {
  	      node.__v_selected = true
  	      frag.appendChild(clone(node))
  	    }
  	  }
  	  return frag
  	}
  
  
  /***/ },
  /* 49 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var templateParser = __webpack_require__(22)
  	var textParser = __webpack_require__(13)
  	var compiler = __webpack_require__(10)
  	var Cache = __webpack_require__(14)
  	var cache = new Cache(1000)
  
  	// v-partial reuses logic from v-if
  	var vIf = __webpack_require__(46)
  
  	module.exports = {
  
  	  link: vIf.link,
  	  teardown: vIf.teardown,
  	  getContainedComponents: vIf.getContainedComponents,
  
  	  bind: function () {
  	    var el = this.el
  	    this.start = _.createAnchor('v-partial-start')
  	    this.end = _.createAnchor('v-partial-end')
  	    _.replace(el, this.end)
  	    _.before(this.start, this.end)
  	    var id = el.getAttribute('name')
  	    var tokens = textParser.parse(id)
  	    if (tokens) {
  	      // dynamic partial
  	      this.setupDynamic(tokens)
  	    } else {
  	      // static partial
  	      this.insert(id)
  	    }
  	  },
  
  	  setupDynamic: function (tokens) {
  	    var self = this
  	    var exp = textParser.tokensToExp(tokens)
  	    this.unwatch = this.vm.$watch(exp, function (value) {
  	      self.teardown()
  	      self.insert(value)
  	    }, {
  	      immediate: true,
  	      user: false
  	    })
  	  },
  
  	  insert: function (id) {
  	    var partial = _.resolveAsset(this.vm.$options, 'partials', id)
  	    if (true) {
  	      _.assertAsset(partial, 'partial', id)
  	    }
  	    if (partial) {
  	      var frag = templateParser.parse(partial, true)
  	      // cache partials based on constructor id.
  	      var cacheId = (this.vm.constructor.cid || '') + partial
  	      var linker = this.compile(frag, cacheId)
  	      // this is provided by v-if
  	      this.link(frag, linker)
  	    }
  	  },
  
  	  compile: function (frag, cacheId) {
  	    var hit = cache.get(cacheId)
  	    if (hit) return hit
  	    var linker = compiler.compile(frag, this.vm.$options, true)
  	    cache.put(cacheId, linker)
  	    return linker
  	  },
  
  	  unbind: function () {
  	    if (this.unlink) this.unlink()
  	    if (this.unwatch) this.unwatch()
  	  }
  	}
  
  
  /***/ },
  /* 50 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	/**
  	 * Stringify value.
  	 *
  	 * @param {Number} indent
  	 */
  
  	exports.json = {
  	  read: function (value, indent) {
  	    return typeof value === 'string'
  	      ? value
  	      : JSON.stringify(value, null, Number(indent) || 2)
  	  },
  	  write: function (value) {
  	    try {
  	      return JSON.parse(value)
  	    } catch (e) {
  	      return value
  	    }
  	  }
  	}
  
  	/**
  	 * 'abc' => 'Abc'
  	 */
  
  	exports.capitalize = function (value) {
  	  if (!value && value !== 0) return ''
  	  value = value.toString()
  	  return value.charAt(0).toUpperCase() + value.slice(1)
  	}
  
  	/**
  	 * 'abc' => 'ABC'
  	 */
  
  	exports.uppercase = function (value) {
  	  return (value || value === 0)
  	    ? value.toString().toUpperCase()
  	    : ''
  	}
  
  	/**
  	 * 'AbC' => 'abc'
  	 */
  
  	exports.lowercase = function (value) {
  	  return (value || value === 0)
  	    ? value.toString().toLowerCase()
  	    : ''
  	}
  
  	/**
  	 * 12345 => $12,345.00
  	 *
  	 * @param {String} sign
  	 */
  
  	var digitsRE = /(\d{3})(?=\d)/g
  	exports.currency = function (value, currency) {
  	  value = parseFloat(value)
  	  if (!isFinite(value) || (!value && value !== 0)) return ''
  	  currency = currency != null ? currency : '$'
  	  var stringified = Math.abs(value).toFixed(2)
  	  var _int = stringified.slice(0, -3)
  	  var i = _int.length % 3
  	  var head = i > 0
  	    ? (_int.slice(0, i) + (_int.length > 3 ? ',' : ''))
  	    : ''
  	  var _float = stringified.slice(-3)
  	  var sign = value < 0 ? '-' : ''
  	  return currency + sign + 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']
  	 */
  
  	exports.pluralize = function (value) {
  	  var args = _.toArray(arguments, 1)
  	  return args.length > 1
  	    ? (args[value % 10 - 1] || args[args.length - 1])
  	    : (args[0] + (value === 1 ? '' : 's'))
  	}
  
  	/**
  	 * A special filter that takes a handler function,
  	 * wraps it so it only gets triggered on specific
  	 * keypresses. v-on only.
  	 *
  	 * @param {String} key
  	 */
  
  	var keyCodes = {
  	  esc: 27,
  	  tab: 9,
  	  enter: 13,
  	  'delete': 46,
  	  up: 38,
  	  left: 37,
  	  right: 39,
  	  down: 40
  	}
  
  	exports.key = function (handler, key) {
  	  if (!handler) return
  	  var code = keyCodes[key]
  	  if (!code) {
  	    code = parseInt(key, 10)
  	  }
  	  return function (e) {
  	    if (e.keyCode === code) {
  	      return handler.call(this, e)
  	    }
  	  }
  	}
  
  	// expose keycode hash
  	exports.key.keyCodes = keyCodes
  
  	exports.debounce = function (handler, delay) {
  	  if (!handler) return
  	  if (!delay) {
  	    delay = 300
  	  }
  	  return _.debounce(handler, delay)
  	}
  
  	/**
  	 * Install special array filters
  	 */
  
  	_.extend(exports, __webpack_require__(51))
  
  
  /***/ },
  /* 51 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var Path = __webpack_require__(20)
  
  	/**
  	 * Filter filter for v-repeat
  	 *
  	 * @param {String} searchKey
  	 * @param {String} [delimiter]
  	 * @param {String} dataKey
  	 */
  
  	exports.filterBy = function (arr, search, delimiter /* ...dataKeys */) {
  	  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 = _.toArray(arguments, n).reduce(function (prev, cur) {
  	    return prev.concat(cur)
  	  }, [])
  	  return arr.filter(function (item) {
  	    return keys.length
  	      ? keys.some(function (key) {
  	          return contains(Path.get(item, key), search)
  	        })
  	      : contains(item, search)
  	  })
  	}
  
  	/**
  	 * Filter filter for v-repeat
  	 *
  	 * @param {String} sortKey
  	 * @param {String} reverse
  	 */
  
  	exports.orderBy = function (arr, sortKey, reverse) {
  	  if (!sortKey) {
  	    return arr
  	  }
  	  var order = 1
  	  if (arguments.length > 2) {
  	    if (reverse === '-1') {
  	      order = -1
  	    } else {
  	      order = reverse ? -1 : 1
  	    }
  	  }
  	  // sort on a copy to avoid mutating original array
  	  return arr.slice().sort(function (a, b) {
  	    if (sortKey !== '$key' && sortKey !== '$value') {
  	      if (a && '$value' in a) a = a.$value
  	      if (b && '$value' in b) b = b.$value
  	    }
  	    a = _.isObject(a) ? Path.get(a, sortKey) : a
  	    b = _.isObject(b) ? Path.get(b, sortKey) : b
  	    return a === b ? 0 : a > b ? order : -order
  	  })
  	}
  
  	/**
  	 * String contain helper
  	 *
  	 * @param {*} val
  	 * @param {String} search
  	 */
  
  	function contains (val, search) {
  	  if (_.isPlainObject(val)) {
  	    for (var key in val) {
  	      if (contains(val[key], search)) {
  	        return true
  	      }
  	    }
  	  } else if (_.isArray(val)) {
  	    var i = val.length
  	    while (i--) {
  	      if (contains(val[i], search)) {
  	        return true
  	      }
  	    }
  	  } else if (val != null) {
  	    return val.toString().toLowerCase().indexOf(search) > -1
  	  }
  	}
  
  
  /***/ },
  /* 52 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var mergeOptions = __webpack_require__(1).mergeOptions
  
  	/**
  	 * The main init sequence. This is called for every
  	 * instance, including ones that are created from extended
  	 * constructors.
  	 *
  	 * @param {Object} options - this options object should be
  	 *                           the result of merging class
  	 *                           options and the options passed
  	 *                           in to the constructor.
  	 */
  
  	exports._init = function (options) {
  
  	  options = options || {}
  
  	  this.$el = null
  	  this.$parent = options._parent
  	  this.$root = options._root || this
  	  this.$children = []
  	  this.$ = {}           // child vm references
  	  this.$$ = {}          // element references
  	  this._watchers = []   // all watchers as an array
  	  this._directives = [] // all directives
  	  this._childCtors = {} // inherit:true constructors
  
  	  // a flag to avoid this being observed
  	  this._isVue = true
  
  	  // events bookkeeping
  	  this._events = {}            // registered callbacks
  	  this._eventsCount = {}       // for $broadcast optimization
  	  this._eventCancelled = false // for event cancellation
  
  	  // fragment instance properties
  	  this._isFragment = false
  	  this._fragmentStart =    // @type {CommentNode}
  	  this._fragmentEnd = null // @type {CommentNode}
  
  	  // lifecycle state
  	  this._isCompiled =
  	  this._isDestroyed =
  	  this._isReady =
  	  this._isAttached =
  	  this._isBeingDestroyed = false
  	  this._unlinkFn = null
  
  	  // context: the scope in which the component was used,
  	  // and the scope in which props and contents of this
  	  // instance should be compiled in.
  	  this._context =
  	    options._context ||
  	    options._parent
  
  	  // push self into parent / transclusion host
  	  if (this.$parent) {
  	    this.$parent.$children.push(this)
  	  }
  
  	  // props used in v-repeat diffing
  	  this._reused = false
  	  this._staggerOp = null
  
  	  // merge options.
  	  options = this.$options = mergeOptions(
  	    this.constructor.options,
  	    options,
  	    this
  	  )
  
  	  // initialize data as empty object.
  	  // it will be filled up in _initScope().
  	  this._data = {}
  
  	  // initialize data observation and scope inheritance.
  	  this._initScope()
  
  	  // setup event system and option events.
  	  this._initEvents()
  
  	  // call created hook
  	  this._callHook('created')
  
  	  // if `el` option is passed, start compilation.
  	  if (options.el) {
  	    this.$mount(options.el)
  	  }
  	}
  
  
  /***/ },
  /* 53 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var inDoc = _.inDoc
  
  	/**
  	 * Setup the instance's option events & watchers.
  	 * If the value is a string, we pull it from the
  	 * instance's methods by name.
  	 */
  
  	exports._initEvents = function () {
  	  var options = this.$options
  	  registerCallbacks(this, '$on', options.events)
  	  registerCallbacks(this, '$watch', options.watch)
  	}
  
  	/**
  	 * Register callbacks for option events and watchers.
  	 *
  	 * @param {Vue} vm
  	 * @param {String} action
  	 * @param {Object} hash
  	 */
  
  	function registerCallbacks (vm, action, hash) {
  	  if (!hash) return
  	  var handlers, key, i, j
  	  for (key in hash) {
  	    handlers = hash[key]
  	    if (_.isArray(handlers)) {
  	      for (i = 0, j = handlers.length; i < j; i++) {
  	        register(vm, action, key, handlers[i])
  	      }
  	    } else {
  	      register(vm, action, key, handlers)
  	    }
  	  }
  	}
  
  	/**
  	 * Helper to register an event/watch callback.
  	 *
  	 * @param {Vue} vm
  	 * @param {String} action
  	 * @param {String} key
  	 * @param {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 + '".'
  	      )
  	    }
  	  } else if (handler && type === 'object') {
  	    register(vm, action, key, handler.handler, handler)
  	  }
  	}
  
  	/**
  	 * Setup recursive attached/detached calls
  	 */
  
  	exports._initDOMHooks = function () {
  	  this.$on('hook:attached', onAttached)
  	  this.$on('hook:detached', onDetached)
  	}
  
  	/**
  	 * Callback to recursively call attached hook on children
  	 */
  
  	function onAttached () {
  	  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
  	 */
  
  	exports._callHook = function (hook) {
  	  var handlers = this.$options[hook]
  	  if (handlers) {
  	    for (var i = 0, j = handlers.length; i < j; i++) {
  	      handlers[i].call(this)
  	    }
  	  }
  	  this.$emit('hook:' + hook)
  	}
  
  
  /***/ },
  /* 54 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var compiler = __webpack_require__(10)
  	var Observer = __webpack_require__(55)
  	var Dep = __webpack_require__(18)
  	var Watcher = __webpack_require__(17)
  
  	/**
  	 * Setup the scope of an instance, which contains:
  	 * - observed data
  	 * - computed properties
  	 * - user methods
  	 * - meta properties
  	 */
  
  	exports._initScope = function () {
  	  this._initProps()
  	  this._initMeta()
  	  this._initMethods()
  	  this._initData()
  	  this._initComputed()
  	}
  
  	/**
  	 * Initialize props.
  	 */
  
  	exports._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.'
  	    )
  	  }
  	  // make sure to convert string selectors into element now
  	  el = options.el = _.query(el)
  	  this._propsUnlinkFn = el && el.nodeType === 1 && props
  	    ? compiler.compileAndLinkProps(
  	        this, el, props
  	      )
  	    : null
  	}
  
  	/**
  	 * Initialize the data.
  	 */
  
  	exports._initData = function () {
  	  var propsData = this._data
  	  var optionsDataFn = this.$options.data
  	  var optionsData = optionsDataFn && optionsDataFn()
  	  if (optionsData) {
  	    this._data = optionsData
  	    for (var prop in propsData) {
  	      if (
  	        this._props[prop].raw !== null ||
  	        !optionsData.hasOwnProperty(prop)
  	      ) {
  	        optionsData.$set(prop, propsData[prop])
  	      }
  	    }
  	  }
  	  var data = this._data
  	  // proxy data on instance
  	  var keys = Object.keys(data)
  	  var i, key
  	  i = keys.length
  	  while (i--) {
  	    key = keys[i]
  	    if (!_.isReserved(key)) {
  	      this._proxy(key)
  	    }
  	  }
  	  // observe data
  	  Observer.create(data, this)
  	}
  
  	/**
  	 * Swap the isntance's $data. Called in $data's setter.
  	 *
  	 * @param {Object} newData
  	 */
  
  	exports._setData = function (newData) {
  	  newData = newData || {}
  	  var oldData = this._data
  	  this._data = newData
  	  var keys, key, i
  	  // copy props.
  	  // this should only happen during a v-repeat of component
  	  // that also happens to have compiled props.
  	  var props = this.$options.props
  	  if (props) {
  	    i = props.length
  	    while (i--) {
  	      key = props[i].name
  	      if (key !== '$data' && !newData.hasOwnProperty(key)) {
  	        newData.$set(key, oldData[key])
  	      }
  	    }
  	  }
  	  // unproxy keys not present in new data
  	  keys = Object.keys(oldData)
  	  i = keys.length
  	  while (i--) {
  	    key = keys[i]
  	    if (!_.isReserved(key) && !(key in newData)) {
  	      this._unproxy(key)
  	    }
  	  }
  	  // proxy keys not already proxied,
  	  // and trigger change for changed values
  	  keys = Object.keys(newData)
  	  i = keys.length
  	  while (i--) {
  	    key = keys[i]
  	    if (!this.hasOwnProperty(key) && !_.isReserved(key)) {
  	      // new property
  	      this._proxy(key)
  	    }
  	  }
  	  oldData.__ob__.removeVm(this)
  	  Observer.create(newData, this)
  	  this._digest()
  	}
  
  	/**
  	 * Proxy a property, so that
  	 * vm.prop === vm._data.prop
  	 *
  	 * @param {String} key
  	 */
  
  	exports._proxy = function (key) {
  	  // need to store ref to self here
  	  // because these getter/setters might
  	  // be called by child instances!
  	  var self = this
  	  Object.defineProperty(self, key, {
  	    configurable: true,
  	    enumerable: true,
  	    get: function proxyGetter () {
  	      return self._data[key]
  	    },
  	    set: function proxySetter (val) {
  	      self._data[key] = val
  	    }
  	  })
  	}
  
  	/**
  	 * Unproxy a property.
  	 *
  	 * @param {String} key
  	 */
  
  	exports._unproxy = function (key) {
  	  delete this[key]
  	}
  
  	/**
  	 * Force update on every watcher in scope.
  	 */
  
  	exports._digest = function () {
  	  var i = this._watchers.length
  	  while (i--) {
  	    this._watchers[i].update(true) // shallow updates
  	  }
  	  var children = this.$children
  	  i = children.length
  	  while (i--) {
  	    var child = children[i]
  	    if (child.$options.inherit) {
  	      child._digest()
  	    }
  	  }
  	}
  
  	/**
  	 * Setup computed properties. They are essentially
  	 * special getter/setters
  	 */
  
  	function noop () {}
  	exports._initComputed = function () {
  	  var computed = this.$options.computed
  	  if (computed) {
  	    for (var key in computed) {
  	      var userDef = computed[key]
  	      var def = {
  	        enumerable: true,
  	        configurable: true
  	      }
  	      if (typeof userDef === 'function') {
  	        def.get = 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 called by children
  	 * inheriting them.
  	 */
  
  	exports._initMethods = function () {
  	  var methods = this.$options.methods
  	  if (methods) {
  	    for (var key in methods) {
  	      this[key] = _.bind(methods[key], this)
  	    }
  	  }
  	}
  
  	/**
  	 * Initialize meta information like $index, $key & $value.
  	 */
  
  	exports._initMeta = function () {
  	  var metas = this.$options._meta
  	  if (metas) {
  	    for (var key in metas) {
  	      this._defineMeta(key, metas[key])
  	    }
  	  }
  	}
  
  	/**
  	 * Define a meta property, e.g $index, $key, $value
  	 * which only exists on the vm instance but not in $data.
  	 *
  	 * @param {String} key
  	 * @param {*} value
  	 */
  
  	exports._defineMeta = function (key, value) {
  	  var dep = new Dep()
  	  Object.defineProperty(this, key, {
  	    get: function metaGetter () {
  	      if (Dep.target) {
  	        dep.depend()
  	      }
  	      return value
  	    },
  	    set: function metaSetter (val) {
  	      if (val !== value) {
  	        value = val
  	        dep.notify()
  	      }
  	    }
  	  })
  	}
  
  
  /***/ },
  /* 55 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  	var Dep = __webpack_require__(18)
  	var arrayMethods = __webpack_require__(56)
  	var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
  	__webpack_require__(57)
  
  	/**
  	 * 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()
  	  _.define(value, '__ob__', this)
  	  if (_.isArray(value)) {
  	    var augment = config.proto && _.hasProto
  	      ? protoAugment
  	      : copyAugment
  	    augment(value, arrayMethods, arrayKeys)
  	    this.observeArray(value)
  	  } else {
  	    this.walk(value)
  	  }
  	}
  
  	// Static methods
  
  	/**
  	 * 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
  	 */
  
  	Observer.create = function (value, vm) {
  	  var ob
  	  if (
  	    value &&
  	    value.hasOwnProperty('__ob__') &&
  	    value.__ob__ instanceof Observer
  	  ) {
  	    ob = value.__ob__
  	  } else if (
  	    _.isObject(value) &&
  	    !Object.isFrozen(value) &&
  	    !value._isVue
  	  ) {
  	    ob = new Observer(value)
  	  }
  	  if (ob && vm) {
  	    ob.addVm(vm)
  	  }
  	  return ob
  	}
  
  	// Instance methods
  
  	/**
  	 * Walk through each property and convert them into
  	 * getter/setters. This method should only be called when
  	 * value type is Object. Properties prefixed with `$` or `_`
  	 * and accessor properties are ignored.
  	 *
  	 * @param {Object} obj
  	 */
  
  	Observer.prototype.walk = function (obj) {
  	  var keys = Object.keys(obj)
  	  var i = keys.length
  	  while (i--) {
  	    this.convert(keys[i], obj[keys[i]])
  	  }
  	}
  
  	/**
  	 * Try to carete an observer for a child value,
  	 * and if value is array, link dep to the array.
  	 *
  	 * @param {*} val
  	 * @return {Dep|undefined}
  	 */
  
  	Observer.prototype.observe = function (val) {
  	  return Observer.create(val)
  	}
  
  	/**
  	 * Observe a list of Array items.
  	 *
  	 * @param {Array} items
  	 */
  
  	Observer.prototype.observeArray = function (items) {
  	  var i = items.length
  	  while (i--) {
  	    this.observe(items[i])
  	  }
  	}
  
  	/**
  	 * Convert a property into getter/setter so we can emit
  	 * the events when the property is accessed/changed.
  	 *
  	 * @param {String} key
  	 * @param {*} val
  	 */
  
  	Observer.prototype.convert = function (key, val) {
  	  var ob = this
  	  var childOb = ob.observe(val)
  	  var dep = new Dep()
  	  Object.defineProperty(ob.value, key, {
  	    enumerable: true,
  	    configurable: true,
  	    get: function () {
  	      if (Dep.target) {
  	        dep.depend()
  	        if (childOb) {
  	          childOb.dep.depend()
  	        }
  	        if (_.isArray(val)) {
  	          for (var e, i = 0, l = val.length; i < l; i++) {
  	            e = val[i]
  	            e && e.__ob__ && e.__ob__.dep.depend()
  	          }
  	        }
  	      }
  	      return val
  	    },
  	    set: function (newVal) {
  	      if (newVal === val) return
  	      val = newVal
  	      childOb = ob.observe(newVal)
  	      dep.notify()
  	    }
  	  })
  	}
  
  	/**
  	 * Add an owner vm, so that when $add/$delete mutations
  	 * happen we can notify owner vms to proxy the keys and
  	 * digest the watchers. This is only called when the object
  	 * is observed as an instance's root $data.
  	 *
  	 * @param {Vue} vm
  	 */
  
  	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} proto
  	 */
  
  	function protoAugment (target, src) {
  	  target.__proto__ = src
  	}
  
  	/**
  	 * Augment an target Object or Array by defining
  	 * hidden properties.
  	 *
  	 * @param {Object|Array} target
  	 * @param {Object} proto
  	 */
  
  	function copyAugment (target, src, keys) {
  	  var i = keys.length
  	  var key
  	  while (i--) {
  	    key = keys[i]
  	    _.define(target, key, src[key])
  	  }
  	}
  
  	module.exports = Observer
  
  
  /***/ },
  /* 56 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var arrayProto = Array.prototype
  	var arrayMethods = Object.create(arrayProto)
  
  	/**
  	 * Intercept mutating methods and emit events
  	 */
  
  	;[
  	  'push',
  	  'pop',
  	  'shift',
  	  'unshift',
  	  'splice',
  	  'sort',
  	  'reverse'
  	]
  	.forEach(function (method) {
  	  // cache original method
  	  var original = arrayProto[method]
  	  _.define(arrayMethods, method, function mutator () {
  	    // avoid leaking arguments:
  	    // http://jsperf.com/closure-with-arguments
  	    var i = arguments.length
  	    var args = new Array(i)
  	    while (i--) {
  	      args[i] = arguments[i]
  	    }
  	    var result = original.apply(this, args)
  	    var ob = this.__ob__
  	    var inserted
  	    switch (method) {
  	      case 'push':
  	        inserted = args
  	        break
  	      case 'unshift':
  	        inserted = args
  	        break
  	      case 'splice':
  	        inserted = args.slice(2)
  	        break
  	    }
  	    if (inserted) ob.observeArray(inserted)
  	    // notify change
  	    ob.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
  	 */
  
  	_.define(
  	  arrayProto,
  	  '$set',
  	  function $set (index, val) {
  	    if (index >= this.length) {
  	      this.length = index + 1
  	    }
  	    return this.splice(index, 1, val)[0]
  	  }
  	)
  
  	/**
  	 * Convenience method to remove the element at given index.
  	 *
  	 * @param {Number} index
  	 * @param {*} val
  	 */
  
  	_.define(
  	  arrayProto,
  	  '$remove',
  	  function $remove (index) {
  	    /* istanbul ignore if */
  	    if (!this.length) return
  	    if (typeof index !== 'number') {
  	      index = _.indexOf(this, index)
  	    }
  	    if (index > -1) {
  	      return this.splice(index, 1)
  	    }
  	  }
  	)
  
  	module.exports = arrayMethods
  
  
  /***/ },
  /* 57 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var objProto = Object.prototype
  
  	/**
  	 * Add a new property to an observed object
  	 * and emits corresponding event
  	 *
  	 * @param {String} key
  	 * @param {*} val
  	 * @public
  	 */
  
  	_.define(
  	  objProto,
  	  '$add',
  	  function $add (key, val) {
  	    if (this.hasOwnProperty(key)) return
  	    var ob = this.__ob__
  	    if (!ob || _.isReserved(key)) {
  	      this[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()
  	      }
  	    }
  	  }
  	)
  
  	/**
  	 * Set a property on an observed object, calling add to
  	 * ensure the property is observed.
  	 *
  	 * @param {String} key
  	 * @param {*} val
  	 * @public
  	 */
  
  	_.define(
  	  objProto,
  	  '$set',
  	  function $set (key, val) {
  	    this.$add(key, val)
  	    this[key] = val
  	  }
  	)
  
  	/**
  	 * Deletes a property from an observed object
  	 * and emits corresponding event
  	 *
  	 * @param {String} key
  	 * @public
  	 */
  
  	_.define(
  	  objProto,
  	  '$delete',
  	  function $delete (key) {
  	    if (!this.hasOwnProperty(key)) return
  	    delete this[key]
  	    var ob = this.__ob__
  	    if (!ob || _.isReserved(key)) {
  	      return
  	    }
  	    ob.dep.notify()
  	    if (ob.vms) {
  	      var i = ob.vms.length
  	      while (i--) {
  	        var vm = ob.vms[i]
  	        vm._unproxy(key)
  	        vm._digest()
  	      }
  	    }
  	  }
  	)
  
  
  /***/ },
  /* 58 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var Directive = __webpack_require__(59)
  	var compiler = __webpack_require__(10)
  
  	/**
  	 * Transclude, compile and link element.
  	 *
  	 * If a pre-compiled linker is available, that means the
  	 * passed in element will be pre-transcluded and compiled
  	 * as well - all we need to do is to call the linker.
  	 *
  	 * Otherwise we need to call transclude/compile/link here.
  	 *
  	 * @param {Element} el
  	 * @return {Element}
  	 */
  
  	exports._compile = function (el) {
  	  var options = this.$options
  	  var host = this._host
  	  if (options._linkFn) {
  	    // pre-transcluded with linker, just use it
  	    this._initElement(el)
  	    this._unlinkFn = options._linkFn(this, el, host)
  	  } else {
  	    // 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 = compiler.transclude(el, options)
  	    this._initElement(el)
  
  	    // root is always compiled per-instance, because
  	    // container attrs and props can be different every time.
  	    var rootLinker = compiler.compileRoot(el, options)
  
  	    // 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 = compiler.compile(el, options)
  	      }
  	    }
  
  	    // link phase
  	    var rootUnlinkFn = rootLinker(this, el)
  	    var contentUnlinkFn = contentLinkFn
  	      ? contentLinkFn(this, el)
  	      : compiler.compile(el, options)(this, el, host)
  
  	    // 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)
  	    }
  	  }
  	  return el
  	}
  
  	/**
  	 * Initialize instance element. Called in the public
  	 * $mount() method.
  	 *
  	 * @param {Element} el
  	 */
  
  	exports._initElement = function (el) {
  	  if (el instanceof DocumentFragment) {
  	    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._blockFragment = el
  	  } else {
  	    this.$el = el
  	  }
  	  this.$el.__vue__ = this
  	  this._callHook('beforeCompile')
  	}
  
  	/**
  	 * Create and bind a directive to an element.
  	 *
  	 * @param {String} name - directive name
  	 * @param {Node} node   - target node
  	 * @param {Object} desc - parsed directive descriptor
  	 * @param {Object} def  - directive definition object
  	 * @param {Vue|undefined} host - transclusion host component
  	 */
  
  	exports._bindDir = function (name, node, desc, def, host) {
  	  this._directives.push(
  	    new Directive(name, node, this, desc, def, host)
  	  )
  	}
  
  	/**
  	 * 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
  	 */
  
  	exports._destroy = function (remove, deferCleanup) {
  	  if (this._isBeingDestroyed) {
  	    return
  	  }
  	  this._callHook('beforeDestroy')
  	  this._isBeingDestroyed = true
  	  var i
  	  // remove self from parent. only necessary
  	  // if parent is not being destroyed as well.
  	  var parent = this.$parent
  	  if (parent && !parent._isBeingDestroyed) {
  	    parent.$children.$remove(this)
  	  }
  	  // 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
  	  }
  	  // remove DOM element
  	  var self = this
  	  if (remove && this.$el) {
  	    this.$remove(function () {
  	      self._cleanup()
  	    })
  	  } else if (!deferCleanup) {
  	    this._cleanup()
  	  }
  	}
  
  	/**
  	 * Clean up to ensure garbage collection.
  	 * This is called after the leave transition if there
  	 * is any.
  	 */
  
  	exports._cleanup = function () {
  	  // remove reference from data ob
  	  // frozen object may not have observer.
  	  if (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._directives = null
  	  // call the last hook...
  	  this._isDestroyed = true
  	  this._callHook('destroyed')
  	  // turn off all instance listeners.
  	  this.$off()
  	}
  
  
  /***/ },
  /* 59 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var config = __webpack_require__(5)
  	var Watcher = __webpack_require__(17)
  	var textParser = __webpack_require__(13)
  	var expParser = __webpack_require__(19)
  
  	/**
  	 * A directive links a DOM element with a piece of data,
  	 * which is the result of evaluating an expression.
  	 * It registers a watcher with the expression and calls
  	 * the DOM update function when a change is triggered.
  	 *
  	 * @param {String} name
  	 * @param {Node} el
  	 * @param {Vue} vm
  	 * @param {Object} descriptor
  	 *                 - {String} expression
  	 *                 - {String} [arg]
  	 *                 - {Array<Object>} [filters]
  	 * @param {Object} def - directive definition object
  	 * @param {Vue|undefined} host - transclusion host target
  	 * @constructor
  	 */
  
  	function Directive (name, el, vm, descriptor, def, host) {
  	  // public
  	  this.name = name
  	  this.el = el
  	  this.vm = vm
  	  // copy descriptor props
  	  this.raw = descriptor.raw
  	  this.expression = descriptor.expression
  	  this.arg = descriptor.arg
  	  this.filters = descriptor.filters
  	  // private
  	  this._descriptor = descriptor
  	  this._host = host
  	  this._locked = false
  	  this._bound = false
  	  this._listeners = null
  	  // init
  	  this._bind(def)
  	}
  
  	/**
  	 * Initialize the directive, mixin definition properties,
  	 * setup the watcher, call definition bind() and update()
  	 * if present.
  	 *
  	 * @param {Object} def
  	 */
  
  	Directive.prototype._bind = function (def) {
  	  if (
  	    (this.name !== 'cloak' || this.vm._isCompiled) &&
  	    this.el && this.el.removeAttribute
  	  ) {
  	    this.el.removeAttribute(config.prefix + this.name)
  	  }
  	  if (typeof def === 'function') {
  	    this.update = def
  	  } else {
  	    _.extend(this, def)
  	  }
  	  this._watcherExp = this.expression
  	  this._checkDynamicLiteral()
  	  if (this.bind) {
  	    this.bind()
  	  }
  	  if (this._watcherExp &&
  	      (this.update || this.twoWay) &&
  	      (!this.isLiteral || this._isDynamicLiteral) &&
  	      !this._checkStatement()) {
  	    // wrapped updater for context
  	    var dir = this
  	    var update = this._update = this.update
  	      ? function (val, oldVal) {
  	          if (!dir._locked) {
  	            dir.update(val, oldVal)
  	          }
  	        }
  	      : function () {} // noop if no update is provided
  	    // pre-process hook called before the value is piped
  	    // through the filters. used in v-repeat.
  	    var preProcess = this._preProcess
  	      ? _.bind(this._preProcess, this)
  	      : null
  	    var watcher = this._watcher = new Watcher(
  	      this.vm,
  	      this._watcherExp,
  	      update, // callback
  	      {
  	        filters: this.filters,
  	        twoWay: this.twoWay,
  	        deep: this.deep,
  	        preProcess: preProcess
  	      }
  	    )
  	    if (this._initValue != null) {
  	      watcher.set(this._initValue)
  	    } else if (this.update) {
  	      this.update(watcher.value)
  	    }
  	  }
  	  this._bound = true
  	}
  
  	/**
  	 * check if this is a dynamic literal binding.
  	 *
  	 * e.g. v-component="{{currentView}}"
  	 */
  
  	Directive.prototype._checkDynamicLiteral = function () {
  	  var expression = this.expression
  	  if (expression && this.isLiteral) {
  	    var tokens = textParser.parse(expression)
  	    if (tokens) {
  	      var exp = textParser.tokensToExp(tokens)
  	      this.expression = this.vm.$get(exp)
  	      this._watcherExp = exp
  	      this._isDynamicLiteral = true
  	    }
  	  }
  	}
  
  	/**
  	 * Check if the directive is a function caller
  	 * and if the expression is a callable one. If both true,
  	 * we wrap up the expression and use it as the event
  	 * handler.
  	 *
  	 * e.g. v-on="click: a++"
  	 *
  	 * @return {Boolean}
  	 */
  
  	Directive.prototype._checkStatement = function () {
  	  var expression = this.expression
  	  if (
  	    expression && this.acceptStatement &&
  	    !expParser.isSimplePath(expression)
  	  ) {
  	    var fn = expParser.parse(expression).get
  	    var vm = this.vm
  	    var handler = function () {
  	      fn.call(vm, vm)
  	    }
  	    if (this.filters) {
  	      handler = vm._applyFilters(handler, null, this.filters)
  	    }
  	    this.update(handler)
  	    return true
  	  }
  	}
  
  	/**
  	 * Check for an attribute directive param, e.g. lazy
  	 *
  	 * @param {String} name
  	 * @return {String}
  	 */
  
  	Directive.prototype._checkParam = function (name) {
  	  var param = this.el.getAttribute(name)
  	  if (param !== null) {
  	    this.el.removeAttribute(name)
  	    param = this.vm.$interpolate(param)
  	  }
  	  return param
  	}
  
  	/**
  	 * 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 (true) {
  	    _.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
  	 */
  
  	Directive.prototype.on = function (event, handler) {
  	  _.on(this.el, event, handler)
  	  ;(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
  	    if (listeners) {
  	      for (var i = 0; i < listeners.length; i++) {
  	        _.off(this.el, listeners[i][0], listeners[i][1])
  	      }
  	    }
  	    this.vm = this.el =
  	    this._watcher = this._listeners = null
  	  }
  	}
  
  	module.exports = Directive
  
  
  /***/ },
  /* 60 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	/**
  	 * 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 {*}
  	 */
  
  	exports._applyFilters = function (value, oldValue, filters, write) {
  	  var filter, fn, args, arg, offset, i, l, j, k
  	  for (i = 0, l = filters.length; i < l; i++) {
  	    filter = filters[i]
  	    fn = _.resolveAsset(this.$options, 'filters', filter.name)
  	    if (true) {
  	      _.assertAsset(fn, 'filter', filter.name)
  	    }
  	    if (!fn) continue
  	    fn = write ? fn.write : (fn.read || fn)
  	    if (typeof fn !== 'function') continue
  	    args = write ? [value, oldValue] : [value]
  	    offset = write ? 2 : 1
  	    if (filter.args) {
  	      for (j = 0, k = filter.args.length; j < k; j++) {
  	        arg = filter.args[j]
  	        args[j + offset] = arg.dynamic
  	          ? this.$get(arg.value)
  	          : arg.value
  	      }
  	    }
  	    value = fn.apply(this, args)
  	  }
  	  return 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} id
  	 * @param {Function} cb
  	 */
  
  	exports._resolveComponent = function (id, cb) {
  	  var factory = _.resolveAsset(this.$options, 'components', id)
  	  if (true) {
  	    _.assertAsset(factory, 'component', id)
  	  }
  	  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(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: ' + id + '. ' +
  	          (reason ? '\nReason: ' + reason : '')
  	        )
  	      })
  	    }
  	  } else {
  	    // normal component
  	    cb(factory)
  	  }
  	}
  
  
  /***/ },
  /* 61 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var Watcher = __webpack_require__(17)
  	var Path = __webpack_require__(20)
  	var textParser = __webpack_require__(13)
  	var dirParser = __webpack_require__(15)
  	var expParser = __webpack_require__(19)
  	var filterRE = /[^|]\|[^|]/
  
  	/**
  	 * Get the value from an expression on this vm.
  	 *
  	 * @param {String} exp
  	 * @return {*}
  	 */
  
  	exports.$get = function (exp) {
  	  var res = expParser.parse(exp)
  	  if (res) {
  	    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
  	 */
  
  	exports.$set = function (exp, val) {
  	  var res = expParser.parse(exp, true)
  	  if (res && res.set) {
  	    res.set.call(this, this, val)
  	  }
  	}
  
  	/**
  	 * Add a property on the VM
  	 *
  	 * @param {String} key
  	 * @param {*} val
  	 */
  
  	exports.$add = function (key, val) {
  	  this._data.$add(key, val)
  	}
  
  	/**
  	 * Delete a property on the VM
  	 *
  	 * @param {String} key
  	 */
  
  	exports.$delete = function (key) {
  	  this._data.$delete(key)
  	}
  
  	/**
  	 * Watch an expression, trigger callback when its
  	 * value changes.
  	 *
  	 * @param {String} exp
  	 * @param {Function} cb
  	 * @param {Object} [options]
  	 *                 - {Boolean} deep
  	 *                 - {Boolean} immediate
  	 *                 - {Boolean} user
  	 * @return {Function} - unwatchFn
  	 */
  
  	exports.$watch = function (exp, cb, options) {
  	  var vm = this
  	  var watcher = new Watcher(vm, exp, cb, {
  	    deep: options && options.deep,
  	    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
  	 * @return {String}
  	 */
  
  	exports.$eval = function (text) {
  	  // check for filters.
  	  if (filterRE.test(text)) {
  	    var dir = dirParser.parse(text)[0]
  	    // the filter regex check might give false positive
  	    // for pipes inside strings, so it's possible that
  	    // we don't get any filters here
  	    var val = this.$get(dir.expression)
  	    return dir.filters
  	      ? this._applyFilters(val, null, dir.filters)
  	      : val
  	  } else {
  	    // no filter
  	    return this.$get(text)
  	  }
  	}
  
  	/**
  	 * Interpolate a piece of template text.
  	 *
  	 * @param {String} text
  	 * @return {String}
  	 */
  
  	exports.$interpolate = function (text) {
  	  var tokens = textParser.parse(text)
  	  var vm = this
  	  if (tokens) {
  	    return tokens.length === 1
  	      ? vm.$eval(tokens[0].value)
  	      : tokens.map(function (token) {
  	          return token.tag
  	            ? vm.$eval(token.value)
  	            : token.value
  	        }).join('')
  	  } else {
  	    return text
  	  }
  	}
  
  	/**
  	 * Log instance data as a plain JS object
  	 * so that it is easier to inspect in console.
  	 * This method assumes console is available.
  	 *
  	 * @param {String} [path]
  	 */
  
  	exports.$log = function (path) {
  	  var data = path
  	    ? Path.get(this._data, path)
  	    : this._data
  	  if (data) {
  	    data = JSON.parse(JSON.stringify(data))
  	  }
  	  console.log(data)
  	}
  
  
  /***/ },
  /* 62 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var transition = __webpack_require__(30)
  
  	/**
  	 * 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
  	 */
  
  	exports.$nextTick = function (fn) {
  	  _.nextTick(fn, this)
  	}
  
  	/**
  	 * Append instance to target
  	 *
  	 * @param {Node} target
  	 * @param {Function} [cb]
  	 * @param {Boolean} [withTransition] - defaults to true
  	 */
  
  	exports.$appendTo = function (target, cb, withTransition) {
  	  return insert(
  	    this, target, cb, withTransition,
  	    append, transition.append
  	  )
  	}
  
  	/**
  	 * Prepend instance to target
  	 *
  	 * @param {Node} target
  	 * @param {Function} [cb]
  	 * @param {Boolean} [withTransition] - defaults to true
  	 */
  
  	exports.$prependTo = function (target, cb, withTransition) {
  	  target = query(target)
  	  if (target.hasChildNodes()) {
  	    this.$before(target.firstChild, cb, withTransition)
  	  } else {
  	    this.$appendTo(target, cb, withTransition)
  	  }
  	  return this
  	}
  
  	/**
  	 * Insert instance before target
  	 *
  	 * @param {Node} target
  	 * @param {Function} [cb]
  	 * @param {Boolean} [withTransition] - defaults to true
  	 */
  
  	exports.$before = function (target, cb, withTransition) {
  	  return insert(
  	    this, target, cb, withTransition,
  	    before, transition.before
  	  )
  	}
  
  	/**
  	 * Insert instance after target
  	 *
  	 * @param {Node} target
  	 * @param {Function} [cb]
  	 * @param {Boolean} [withTransition] - defaults to true
  	 */
  
  	exports.$after = function (target, cb, withTransition) {
  	  target = query(target)
  	  if (target.nextSibling) {
  	    this.$before(target.nextSibling, cb, withTransition)
  	  } else {
  	    this.$appendTo(target.parentNode, cb, withTransition)
  	  }
  	  return this
  	}
  
  	/**
  	 * Remove instance from DOM
  	 *
  	 * @param {Function} [cb]
  	 * @param {Boolean} [withTransition] - defaults to true
  	 */
  
  	exports.$remove = function (cb, withTransition) {
  	  if (!this.$el.parentNode) {
  	    return cb && cb()
  	  }
  	  var inDoc = this._isAttached && _.inDoc(this.$el)
  	  // if we are not in document, no need to check
  	  // for transitions
  	  if (!inDoc) withTransition = false
  	  var op
  	  var self = this
  	  var realCb = function () {
  	    if (inDoc) self._callHook('detached')
  	    if (cb) cb()
  	  }
  	  if (
  	    this._isFragment &&
  	    !this._blockFragment.hasChildNodes()
  	  ) {
  	    op = withTransition === false
  	      ? append
  	      : transition.removeThenAppend
  	    blockOp(this, this._blockFragment, op, realCb)
  	  } else {
  	    op = withTransition === false
  	      ? remove
  	      : transition.remove
  	    op(this.$el, this, realCb)
  	  }
  	  return this
  	}
  
  	/**
  	 * Shared DOM insertion function.
  	 *
  	 * @param {Vue} vm
  	 * @param {Element} target
  	 * @param {Function} [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) {
  	    blockOp(vm, target, op, cb)
  	  } else {
  	    op(vm.$el, target, vm, cb)
  	  }
  	  if (shouldCallHook) {
  	    vm._callHook('attached')
  	  }
  	  return vm
  	}
  
  	/**
  	 * Execute a transition operation on a fragment instance,
  	 * iterating through all its block nodes.
  	 *
  	 * @param {Vue} vm
  	 * @param {Node} target
  	 * @param {Function} op
  	 * @param {Function} cb
  	 */
  
  	function blockOp (vm, target, op, cb) {
  	  var current = vm._fragmentStart
  	  var end = vm._fragmentEnd
  	  var next
  	  while (next !== end) {
  	    next = current.nextSibling
  	    op(current, target, vm)
  	    current = next
  	  }
  	  op(end, target, vm, cb)
  	}
  
  	/**
  	 * Check for selectors
  	 *
  	 * @param {String|Element} el
  	 */
  
  	function query (el) {
  	  return typeof el === 'string'
  	    ? document.querySelector(el)
  	    : el
  	}
  
  	/**
  	 * Append operation that takes a callback.
  	 *
  	 * @param {Node} el
  	 * @param {Node} target
  	 * @param {Vue} vm - unused
  	 * @param {Function} [cb]
  	 */
  
  	function append (el, target, vm, cb) {
  	  target.appendChild(el)
  	  if (cb) cb()
  	}
  
  	/**
  	 * InsertBefore operation that takes a callback.
  	 *
  	 * @param {Node} el
  	 * @param {Node} target
  	 * @param {Vue} vm - unused
  	 * @param {Function} [cb]
  	 */
  
  	function before (el, target, vm, cb) {
  	  _.before(el, target)
  	  if (cb) cb()
  	}
  
  	/**
  	 * Remove operation that takes a callback.
  	 *
  	 * @param {Node} el
  	 * @param {Vue} vm - unused
  	 * @param {Function} [cb]
  	 */
  
  	function remove (el, vm, cb) {
  	  _.remove(el)
  	  if (cb) cb()
  	}
  
  
  /***/ },
  /* 63 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	/**
  	 * Listen on the given `event` with `fn`.
  	 *
  	 * @param {String} event
  	 * @param {Function} fn
  	 */
  
  	exports.$on = function (event, fn) {
  	  (this._events[event] || (this._events[event] = []))
  	    .push(fn)
  	  modifyListenerCount(this, event, 1)
  	  return this
  	}
  
  	/**
  	 * Adds an `event` listener that will be invoked a single
  	 * time then automatically removed.
  	 *
  	 * @param {String} event
  	 * @param {Function} fn
  	 */
  
  	exports.$once = function (event, fn) {
  	  var self = this
  	  function on () {
  	    self.$off(event, on)
  	    fn.apply(this, arguments)
  	  }
  	  on.fn = fn
  	  this.$on(event, on)
  	  return this
  	}
  
  	/**
  	 * Remove the given callback for `event` or all
  	 * registered callbacks.
  	 *
  	 * @param {String} event
  	 * @param {Function} fn
  	 */
  
  	exports.$off = function (event, fn) {
  	  var cbs
  	  // all
  	  if (!arguments.length) {
  	    if (this.$parent) {
  	      for (event in this._events) {
  	        cbs = this._events[event]
  	        if (cbs) {
  	          modifyListenerCount(this, event, -cbs.length)
  	        }
  	      }
  	    }
  	    this._events = {}
  	    return this
  	  }
  	  // specific event
  	  cbs = this._events[event]
  	  if (!cbs) {
  	    return this
  	  }
  	  if (arguments.length === 1) {
  	    modifyListenerCount(this, event, -cbs.length)
  	    this._events[event] = null
  	    return this
  	  }
  	  // specific handler
  	  var cb
  	  var i = cbs.length
  	  while (i--) {
  	    cb = cbs[i]
  	    if (cb === fn || cb.fn === fn) {
  	      modifyListenerCount(this, event, -1)
  	      cbs.splice(i, 1)
  	      break
  	    }
  	  }
  	  return this
  	}
  
  	/**
  	 * Trigger an event on self.
  	 *
  	 * @param {String} event
  	 */
  
  	exports.$emit = function (event) {
  	  this._eventCancelled = false
  	  var cbs = this._events[event]
  	  if (cbs) {
  	    // avoid leaking arguments:
  	    // http://jsperf.com/closure-with-arguments
  	    var i = arguments.length - 1
  	    var args = new Array(i)
  	    while (i--) {
  	      args[i] = arguments[i + 1]
  	    }
  	    i = 0
  	    cbs = cbs.length > 1
  	      ? _.toArray(cbs)
  	      : cbs
  	    for (var l = cbs.length; i < l; i++) {
  	      if (cbs[i].apply(this, args) === false) {
  	        this._eventCancelled = true
  	      }
  	    }
  	  }
  	  return this
  	}
  
  	/**
  	 * Recursively broadcast an event to all children instances.
  	 *
  	 * @param {String} event
  	 * @param {...*} additional arguments
  	 */
  
  	exports.$broadcast = function (event) {
  	  // if no child has registered for this event,
  	  // then there's no need to broadcast.
  	  if (!this._eventsCount[event]) return
  	  var children = this.$children
  	  for (var i = 0, l = children.length; i < l; i++) {
  	    var child = children[i]
  	    child.$emit.apply(child, arguments)
  	    if (!child._eventCancelled) {
  	      child.$broadcast.apply(child, arguments)
  	    }
  	  }
  	  return this
  	}
  
  	/**
  	 * Recursively propagate an event up the parent chain.
  	 *
  	 * @param {String} event
  	 * @param {...*} additional arguments
  	 */
  
  	exports.$dispatch = function () {
  	  var parent = this.$parent
  	  while (parent) {
  	    parent.$emit.apply(parent, arguments)
  	    parent = parent._eventCancelled
  	      ? null
  	      : parent.$parent
  	  }
  	  return this
  	}
  
  	/**
  	 * Modify the listener counts on all parents.
  	 * This bookkeeping allows $broadcast to return early when
  	 * no child has listened to a certain event.
  	 *
  	 * @param {Vue} vm
  	 * @param {String} event
  	 * @param {Number} count
  	 */
  
  	var hookRE = /^hook:/
  	function modifyListenerCount (vm, event, count) {
  	  var parent = vm.$parent
  	  // hooks do not get broadcasted so no need
  	  // to do bookkeeping for them
  	  if (!parent || !count || hookRE.test(event)) return
  	  while (parent) {
  	    parent._eventsCount[event] =
  	      (parent._eventsCount[event] || 0) + count
  	    parent = parent.$parent
  	  }
  	}
  
  
  /***/ },
  /* 64 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  
  	/**
  	 * Create a child instance that prototypally inherits
  	 * data on parent. To achieve that we create an intermediate
  	 * constructor with its prototype pointing to parent.
  	 *
  	 * @param {Object} opts
  	 * @param {Function} [BaseCtor]
  	 * @return {Vue}
  	 * @public
  	 */
  
  	exports.$addChild = function (opts, BaseCtor) {
  	  BaseCtor = BaseCtor || _.Vue
  	  opts = opts || {}
  	  var parent = this
  	  var ChildVue
  	  var inherit = opts.inherit !== undefined
  	    ? opts.inherit
  	    : BaseCtor.options.inherit
  	  if (inherit) {
  	    var ctors = parent._childCtors
  	    ChildVue = ctors[BaseCtor.cid]
  	    if (!ChildVue) {
  	      var optionName = BaseCtor.options.name
  	      var className = optionName
  	        ? _.classify(optionName)
  	        : 'VueComponent'
  	      ChildVue = new Function(
  	        'return function ' + className + ' (options) {' +
  	        'this.constructor = ' + className + ';' +
  	        'this._init(options) }'
  	      )()
  	      ChildVue.options = BaseCtor.options
  	      ChildVue.linker = BaseCtor.linker
  	      // important: transcluded inline repeaters should
  	      // inherit from outer scope rather than host
  	      ChildVue.prototype = opts._context || this
  	      ctors[BaseCtor.cid] = ChildVue
  	    }
  	  } else {
  	    ChildVue = BaseCtor
  	  }
  	  opts._parent = parent
  	  opts._root = parent.$root
  	  var child = new ChildVue(opts)
  	  return child
  	}
  
  
  /***/ },
  /* 65 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(1)
  	var compiler = __webpack_require__(10)
  
  	/**
  	 * Set instance target element and kick off the compilation
  	 * process. The passed in `el` can be a selector string, an
  	 * existing Element, or a DocumentFragment (for block
  	 * instances).
  	 *
  	 * @param {Element|DocumentFragment|string} el
  	 * @public
  	 */
  
  	exports.$mount = function (el) {
  	  if (this._isCompiled) {
  	    ("development") !== 'production' && _.warn(
  	      '$mount() should be called only once.'
  	    )
  	    return
  	  }
  	  el = _.query(el)
  	  if (!el) {
  	    el = document.createElement('div')
  	  }
  	  this._compile(el)
  	  this._isCompiled = true
  	  this._callHook('compiled')
  	  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.
  	 */
  
  	exports.$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]
  	 * @return {Function}
  	 */
  
  	exports.$compile = function (el, host) {
  	  return compiler.compile(el, this.$options, true)(this, el, host)
  	}
  
  
  /***/ }
  /******/ ])
  });
  ;
  /**
   * vue-resource v0.1.15
   * https://github.com/vuejs/vue-resource
   * Released under the MIT License.
   */
  
  (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define(factory);
  	else if(typeof exports === 'object')
  		exports["VueResource"] = factory();
  	else
  		root["VueResource"] = factory();
  })(this, function() {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  
  
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * Install plugin.
  	 */
  
  	function install(Vue) {
  
  	    var _ = __webpack_require__(1)(Vue);
  
  	    Vue.url = __webpack_require__(2)(_);
  	    Vue.http = __webpack_require__(3)(_);
  	    Vue.resource = __webpack_require__(7)(_);
  
  	    Object.defineProperties(Vue.prototype, {
  
  	        $url: {
  	            get: function () {
  	                return this._url || (this._url = _.options(Vue.url, this, this.$options.url));
  	            }
  	        },
  
  	        $http: {
  	            get: function () {
  	                return this._http || (this._http = _.options(Vue.http, this, this.$options.http));
  	            }
  	        },
  
  	        $resource: {
  	            get: function () {
  	                return Vue.resource.bind(this);
  	            }
  	        }
  
  	    });
  	}
  
  	if (window.Vue) {
  	    Vue.use(install);
  	}
  
  	module.exports = install;
  
  /***/ },
  /* 1 */
  /***/ function(module, exports) {
  
  	/**
  	 * Utility functions.
  	 */
  
  	module.exports = function (Vue) {
  
  	    var _ = Vue.util.extend({}, Vue.util);
  
  	    _.isString = function (value) {
  	        return typeof value === 'string';
  	    };
  
  	    _.isFunction = function (value) {
  	        return typeof value === 'function';
  	    };
  
  	    _.options = function (fn, obj, options) {
  
  	        options = options || {};
  
  	        if (_.isFunction(options)) {
  	            options = options.call(obj);
  	        }
  
  	        return _.extend(fn.bind({vm: obj, options: options}), fn, {options: options});
  	    };
  
  	    _.each = function (obj, iterator) {
  
  	        var i, key;
  
  	        if (typeof obj.length == 'number') {
  	            for (i = 0; i < obj.length; i++) {
  	                iterator.call(obj[i], obj[i], i);
  	            }
  	        } else if (_.isObject(obj)) {
  	            for (key in obj) {
  	                if (obj.hasOwnProperty(key)) {
  	                    iterator.call(obj[key], obj[key], key);
  	                }
  	            }
  	        }
  
  	        return obj;
  	    };
  
  	    _.extend = function (target) {
  
  	        var array = [], args = array.slice.call(arguments, 1), deep;
  
  	        if (typeof target == 'boolean') {
  	            deep = target;
  	            target = args.shift();
  	        }
  
  	        args.forEach(function (arg) {
  	            extend(target, arg, deep);
  	        });
  
  	        return target;
  	    };
  
  	    function extend(target, source, deep) {
  	        for (var key in source) {
  	            if (deep && (_.isPlainObject(source[key]) || _.isArray(source[key]))) {
  	                if (_.isPlainObject(source[key]) && !_.isPlainObject(target[key])) {
  	                    target[key] = {};
  	                }
  	                if (_.isArray(source[key]) && !_.isArray(target[key])) {
  	                    target[key] = [];
  	                }
  	                extend(target[key], source[key], deep);
  	            } else if (source[key] !== undefined) {
  	                target[key] = source[key];
  	            }
  	        }
  	    }
  
  	    return _;
  	};
  
  
  /***/ },
  /* 2 */
  /***/ function(module, exports) {
  
  	/**
  	 * Service for URL templating.
  	 */
  
  	var el = document.createElement('a');
  
  	module.exports = function (_) {
  
  	    function Url(url, params) {
  
  	        var urlParams = {}, queryParams = {}, options = url, query;
  
  	        if (!_.isPlainObject(options)) {
  	            options = {url: url, params: params};
  	        }
  
  	        options = _.extend(true, {},
  	            Url.options, this.options, options
  	        );
  
  	        url = options.url.replace(/(\/?):([a-z]\w*)/gi, function (match, slash, name) {
  
  	            if (options.params[name]) {
  	                urlParams[name] = true;
  	                return slash + encodeUriSegment(options.params[name]);
  	            }
  
  	            return '';
  	        });
  
  	        if (_.isString(options.root) && !url.match(/^(https?:)?\//)) {
  	            url = options.root + '/' + url;
  	        }
  
  	        _.each(options.params, function (value, key) {
  	            if (!urlParams[key]) {
  	                queryParams[key] = value;
  	            }
  	        });
  
  	        query = Url.params(queryParams);
  
  	        if (query) {
  	            url += (url.indexOf('?') == -1 ? '?' : '&') + query;
  	        }
  
  	        return url;
  	    }
  
  	    /**
  	     * Url options.
  	     */
  
  	    Url.options = {
  	        url: '',
  	        root: null,
  	        params: {}
  	    };
  
  	    /**
  	     * Encodes a Url parameter string.
  	     *
  	     * @param {Object} obj
  	     */
  
  	    Url.params = function (obj) {
  
  	        var params = [];
  
  	        params.add = function (key, value) {
  
  	            if (_.isFunction (value)) {
  	                value = value();
  	            }
  
  	            if (value === null) {
  	                value = '';
  	            }
  
  	            this.push(encodeUriSegment(key) + '=' + encodeUriSegment(value));
  	        };
  
  	        serialize(params, obj);
  
  	        return params.join('&');
  	    };
  
  	    /**
  	     * Parse a URL and return its components.
  	     *
  	     * @param {String} url
  	     */
  
  	    Url.parse = function (url) {
  
  	        el.href = url;
  
  	        return {
  	            href: el.href,
  	            protocol: el.protocol ? el.protocol.replace(/:$/, '') : '',
  	            port: el.port,
  	            host: el.host,
  	            hostname: el.hostname,
  	            pathname: el.pathname.charAt(0) === '/' ? el.pathname : '/' + el.pathname,
  	            search: el.search ? el.search.replace(/^\?/, '') : '',
  	            hash: el.hash ? el.hash.replace(/^#/, '') : ''
  	        };
  	    };
  
  	    function serialize(params, obj, scope) {
  
  	        var array = _.isArray(obj), plain = _.isPlainObject(obj), hash;
  
  	        _.each(obj, function (value, key) {
  
  	            hash = _.isObject(value) || _.isArray(value);
  
  	            if (scope) {
  	                key = scope + '[' + (plain || hash ? key : '') + ']';
  	            }
  
  	            if (!scope && array) {
  	                params.add(value.name, value.value);
  	            } else if (hash) {
  	                serialize(params, value, key);
  	            } else {
  	                params.add(key, value);
  	            }
  	        });
  	    }
  
  	    function encodeUriSegment(value) {
  
  	        return encodeUriQuery(value, true).
  	            replace(/%26/gi, '&').
  	            replace(/%3D/gi, '=').
  	            replace(/%2B/gi, '+');
  	    }
  
  	    function encodeUriQuery(value, spaces) {
  
  	        return encodeURIComponent(value).
  	            replace(/%40/gi, '@').
  	            replace(/%3A/gi, ':').
  	            replace(/%24/g, '$').
  	            replace(/%2C/gi, ',').
  	            replace(/%20/g, (spaces ? '%20' : '+'));
  	    }
  
  	    return _.url = Url;
  	};
  
  
  /***/ },
  /* 3 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * Service for sending network requests.
  	 */
  
  	var xhr = __webpack_require__(4);
  	var jsonp = __webpack_require__(6);
  	var Promise = __webpack_require__(5);
  
  	module.exports = function (_) {
  
  	    var originUrl = _.url.parse(location.href);
  	    var jsonType = {'Content-Type': 'application/json;charset=utf-8'};
  
  	    function Http(url, options) {
  
  	        var promise;
  
  	        if (_.isPlainObject(url)) {
  	            options = url;
  	            url = '';
  	        }
  
  	        options = _.extend({url: url}, options);
  	        options = _.extend(true, {},
  	            Http.options, this.options, options
  	        );
  
  	        if (options.crossOrigin === null) {
  	            options.crossOrigin = crossOrigin(options.url);
  	        }
  
  	        options.method = options.method.toUpperCase();
  	        options.headers = _.extend({}, Http.headers.common,
  	            !options.crossOrigin ? Http.headers.custom : {},
  	            Http.headers[options.method.toLowerCase()],
  	            options.headers
  	        );
  
  	        if (_.isPlainObject(options.data) && /^(GET|JSONP)$/i.test(options.method)) {
  	            _.extend(options.params, options.data);
  	            delete options.data;
  	        }
  
  	        if (options.emulateHTTP && !options.crossOrigin && /^(PUT|PATCH|DELETE)$/i.test(options.method)) {
  	            options.headers['X-HTTP-Method-Override'] = options.method;
  	            options.method = 'POST';
  	        }
  
  	        if (options.emulateJSON && _.isPlainObject(options.data)) {
  	            options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
  	            options.data = _.url.params(options.data);
  	        }
  
  	        if (_.isObject(options.data) && /FormData/i.test(options.data.toString())) {
  	            delete options.headers['Content-Type'];
  	        }
  
  	        if (_.isPlainObject(options.data)) {
  	            options.data = JSON.stringify(options.data);
  	        }
  
  	        promise = (options.method == 'JSONP' ? jsonp : xhr).call(this.vm, _, options);
  	        promise = extendPromise(promise.then(transformResponse, transformResponse), this.vm);
  
  	        if (options.success) {
  	            promise = promise.success(options.success);
  	        }
  
  	        if (options.error) {
  	            promise = promise.error(options.error);
  	        }
  
  	        return promise;
  	    }
  
  	    function extendPromise(promise, vm) {
  
  	        promise.success = function (fn) {
  
  	            return extendPromise(promise.then(function (response) {
  	                return fn.call(vm, response.data, response.status, response) || response;
  	            }), vm);
  
  	        };
  
  	        promise.error = function (fn) {
  
  	            return extendPromise(promise.then(undefined, function (response) {
  	                return fn.call(vm, response.data, response.status, response) || response;
  	            }), vm);
  
  	        };
  
  	        promise.always = function (fn) {
  
  	            var cb = function (response) {
  	                return fn.call(vm, response.data, response.status, response) || response;
  	            };
  
  	            return extendPromise(promise.then(cb, cb), vm);
  	        };
  
  	        return promise;
  	    }
  
  	    function transformResponse(response) {
  
  	        try {
  	            response.data = JSON.parse(response.responseText);
  	        } catch (e) {
  	            response.data = response.responseText;
  	        }
  
  	        return response.ok ? response : Promise.reject(response);
  	    }
  
  	    function crossOrigin(url) {
  
  	        var requestUrl = _.url.parse(url);
  
  	        return (requestUrl.protocol !== originUrl.protocol || requestUrl.host !== originUrl.host);
  	    }
  
  	    Http.options = {
  	        method: 'get',
  	        params: {},
  	        data: '',
  	        xhr: null,
  	        jsonp: 'callback',
  	        beforeSend: null,
  	        crossOrigin: null,
  	        emulateHTTP: false,
  	        emulateJSON: false
  	    };
  
  	    Http.headers = {
  	        put: jsonType,
  	        post: jsonType,
  	        patch: jsonType,
  	        delete: jsonType,
  	        common: {'Accept': 'application/json, text/plain, */*'},
  	        custom: {'X-Requested-With': 'XMLHttpRequest'}
  	    };
  
  	    ['get', 'put', 'post', 'patch', 'delete', 'jsonp'].forEach(function (method) {
  
  	        Http[method] = function (url, data, success, options) {
  
  	            if (_.isFunction(data)) {
  	                options = success;
  	                success = data;
  	                data = undefined;
  	            }
  
  	            return this(url, _.extend({method: method, data: data, success: success}, options));
  	        };
  	    });
  
  	    return _.http = Http;
  	};
  
  
  /***/ },
  /* 4 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * XMLHttp request.
  	 */
  
  	var Promise = __webpack_require__(5);
  
  	module.exports = function (_, options) {
  
  	    var request = new XMLHttpRequest(), promise;
  
  	    if (_.isPlainObject(options.xhr)) {
  	        _.extend(request, options.xhr);
  	    }
  
  	    if (_.isFunction(options.beforeSend)) {
  	        options.beforeSend.call(this, request, options);
  	    }
  
  	    promise = new Promise(function (resolve, reject) {
  
  	        request.open(options.method, _.url(options), true);
  
  	        _.each(options.headers, function (value, header) {
  	            request.setRequestHeader(header, value);
  	        });
  
  	        request.onreadystatechange = function () {
  
  	            if (request.readyState === 4) {
  
  	                request.ok = request.status >= 200 && request.status < 300;
  
  	                (request.ok ? resolve : reject)(request);
  	            }
  	        };
  
  	        request.send(options.data);
  	    });
  
  	    return promise;
  	};
  
  
  /***/ },
  /* 5 */
  /***/ function(module, exports) {
  
  	/**
  	 * Promises/A+ polyfill v1.1.0 (https://github.com/bramstein/promis)
  	 */
  
  	var RESOLVED = 0;
  	var REJECTED = 1;
  	var PENDING  = 2;
  
  	function Promise(executor) {
  
  	    this.state = PENDING;
  	    this.value = undefined;
  	    this.deferred = [];
  
  	    var promise = this;
  
  	    try {
  	        executor(function (x) {
  	            promise.resolve(x);
  	        }, function (r) {
  	            promise.reject(r);
  	        });
  	    } catch (e) {
  	        promise.reject(e);
  	    }
  	}
  
  	Promise.reject = function (r) {
  	    return new Promise(function (resolve, reject) {
  	        reject(r);
  	    });
  	};
  
  	Promise.resolve = function (x) {
  	    return new Promise(function (resolve, reject) {
  	        resolve(x);
  	    });
  	};
  
  	Promise.all = function all(iterable) {
  	    return new Promise(function (resolve, reject) {
  	        var count = 0,
  	            result = [];
  
  	        if (iterable.length === 0) {
  	            resolve(result);
  	        }
  
  	        function resolver(i) {
  	            return function (x) {
  	                result[i] = x;
  	                count += 1;
  
  	                if (count === iterable.length) {
  	                    resolve(result);
  	                }
  	            };
  	        }
  
  	        for (var i = 0; i < iterable.length; i += 1) {
  	            iterable[i].then(resolver(i), reject);
  	        }
  	    });
  	};
  
  	Promise.race = function race(iterable) {
  	    return new Promise(function (resolve, reject) {
  	        for (var i = 0; i < iterable.length; i += 1) {
  	            iterable[i].then(resolve, reject);
  	        }
  	    });
  	};
  
  	var p = Promise.prototype;
  
  	p.resolve = function resolve(x) {
  	    var promise = this;
  
  	    if (promise.state === PENDING) {
  	        if (x === promise) {
  	            throw new TypeError('Promise settled with itself.');
  	        }
  
  	        var called = false;
  
  	        try {
  	            var then = x && x['then'];
  
  	            if (x !== null && typeof x === 'object' && typeof then === 'function') {
  	                then.call(x, function (x) {
  	                    if (!called) {
  	                        promise.resolve(x);
  	                    }
  	                    called = true;
  
  	                }, function (r) {
  	                    if (!called) {
  	                        promise.reject(r);
  	                    }
  	                    called = true;
  	                });
  	                return;
  	            }
  	        } catch (e) {
  	            if (!called) {
  	                promise.reject(e);
  	            }
  	            return;
  	        }
  	        promise.state = RESOLVED;
  	        promise.value = x;
  	        promise.notify();
  	    }
  	};
  
  	p.reject = function reject(reason) {
  	    var promise = this;
  
  	    if (promise.state === PENDING) {
  	        if (reason === promise) {
  	            throw new TypeError('Promise settled with itself.');
  	        }
  
  	        promise.state = REJECTED;
  	        promise.value = reason;
  	        promise.notify();
  	    }
  	};
  
  	p.notify = function notify() {
  	    var promise = this;
  
  	    async(function () {
  	        if (promise.state !== PENDING) {
  	            while (promise.deferred.length) {
  	                var deferred = promise.deferred.shift(),
  	                    onResolved = deferred[0],
  	                    onRejected = deferred[1],
  	                    resolve = deferred[2],
  	                    reject = deferred[3];
  
  	                try {
  	                    if (promise.state === RESOLVED) {
  	                        if (typeof onResolved === 'function') {
  	                            resolve(onResolved.call(undefined, promise.value));
  	                        } else {
  	                            resolve(promise.value);
  	                        }
  	                    } else if (promise.state === REJECTED) {
  	                        if (typeof onRejected === 'function') {
  	                            resolve(onRejected.call(undefined, promise.value));
  	                        } else {
  	                            reject(promise.value);
  	                        }
  	                    }
  	                } catch (e) {
  	                    reject(e);
  	                }
  	            }
  	        }
  	    });
  	};
  
  	p.catch = function (onRejected) {
  	    return this.then(undefined, onRejected);
  	};
  
  	p.then = function then(onResolved, onRejected) {
  	    var promise = this;
  
  	    return new Promise(function (resolve, reject) {
  	        promise.deferred.push([onResolved, onRejected, resolve, reject]);
  	        promise.notify();
  	    });
  	};
  
  	var queue = [];
  	var async = function (callback) {
  	    queue.push(callback);
  
  	    if (queue.length === 1) {
  	        async.async();
  	    }
  	};
  
  	async.run = function () {
  	    while (queue.length) {
  	        queue[0]();
  	        queue.shift();
  	    }
  	};
  
  	if (window.MutationObserver) {
  	    var el = document.createElement('div');
  	    var mo = new MutationObserver(async.run);
  
  	    mo.observe(el, {
  	        attributes: true
  	    });
  
  	    async.async = function () {
  	        el.setAttribute("x", 0);
  	    };
  	} else {
  	    async.async = function () {
  	        setTimeout(async.run);
  	    };
  	}
  
  	module.exports = window.Promise || Promise;
  
  
  /***/ },
  /* 6 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/**
  	 * JSONP request.
  	 */
  
  	var Promise = __webpack_require__(5);
  
  	module.exports = function (_, options) {
  
  	    var callback = '_jsonp' + Math.random().toString(36).substr(2), response = {}, script, body;
  
  	    options.params[options.jsonp] = callback;
  
  	    if (_.isFunction(options.beforeSend)) {
  	        options.beforeSend.call(this, {}, options);
  	    }
  
  	    return new Promise(function (resolve, reject) {
  
  	        script = document.createElement('script');
  	        script.src = _.url(options);
  	        script.type = 'text/javascript';
  	        script.async = true;
  
  	        window[callback] = function (data) {
  	            body = data;
  	        };
  
  	        var handler = function (event) {
  
  	            delete window[callback];
  	            document.body.removeChild(script);
  
  	            if (event.type === 'load' && !body) {
  	                event.type = 'error';
  	            }
  
  	            response.ok = event.type !== 'error';
  	            response.status = response.ok ? 200 : 404;
  	            response.responseText = body ? body : event.type;
  
  	            (response.ok ? resolve : reject)(response);
  	        };
  
  	        script.onload = handler;
  	        script.onerror = handler;
  
  	        document.body.appendChild(script);
  	    });
  
  	};
  
  
  /***/ },
  /* 7 */
  /***/ function(module, exports) {
  
  	/**
  	 * Service for interacting with RESTful services.
  	 */
  
  	module.exports = function (_) {
  
  	    function Resource(url, params, actions) {
  
  	        var self = this, resource = {};
  
  	        actions = _.extend({},
  	            Resource.actions,
  	            actions
  	        );
  
  	        _.each(actions, function (action, name) {
  
  	            action = _.extend(true, {url: url, params: params || {}}, action);
  
  	            resource[name] = function () {
  	                return (self.$http || _.http)(opts(action, arguments));
  	            };
  	        });
  
  	        return resource;
  	    }
  
  	    function opts(action, args) {
  
  	        var options = _.extend({}, action), params = {}, data, success, error;
  
  	        switch (args.length) {
  
  	            case 4:
  
  	                error = args[3];
  	                success = args[2];
  
  	            case 3:
  	            case 2:
  
  	                if (_.isFunction(args[1])) {
  
  	                    if (_.isFunction(args[0])) {
  
  	                        success = args[0];
  	                        error = args[1];
  
  	                        break;
  	                    }
  
  	                    success = args[1];
  	                    error = args[2];
  
  	                } else {
  
  	                    params = args[0];
  	                    data = args[1];
  	                    success = args[2];
  
  	                    break;
  	                }
  
  	            case 1:
  
  	                if (_.isFunction(args[0])) {
  	                    success = args[0];
  	                } else if (/^(POST|PUT|PATCH)$/i.test(options.method)) {
  	                    data = args[0];
  	                } else {
  	                    params = args[0];
  	                }
  
  	                break;
  
  	            case 0:
  
  	                break;
  
  	            default:
  
  	                throw 'Expected up to 4 arguments [params, data, success, error], got ' + args.length + ' arguments';
  	        }
  
  	        options.data = data;
  	        options.params = _.extend({}, options.params, params);
  
  	        if (success) {
  	            options.success = success;
  	        }
  
  	        if (error) {
  	            options.error = error;
  	        }
  
  	        return options;
  	    }
  
  	    Resource.actions = {
  
  	        get: {method: 'GET'},
  	        save: {method: 'POST'},
  	        query: {method: 'GET'},
  	        update: {method: 'PUT'},
  	        remove: {method: 'DELETE'},
  	        delete: {method: 'DELETE'}
  
  	    };
  
  	    return _.resource = Resource;
  	};
  
  
  /***/ }
  /******/ ])
  });
  ;
  $(function () {
      $.ajaxSetup({
          headers: { 'X-CSRF-TOKEN': $('meta[name="_token"]').attr('content') }
      });
  });
  
  /**
   * Cleditor
   */
  $("#descripcion").cleditor();
  
  /**
   * Clientes Select2
   */
  $('#cliente_id').select2({
      width: '100%',
      placeholder: "Selecione un cliente"
  });
  
  /**
   * OpenModal tribunal
   */
  function tribunalModal(){
      $('#modal3').openModal();
  }
  
  /**
   * OpenModal Juez_id
   */
  function juezModal(){
      $('#modal1').openModal();
  }
  
  /**
   * OpenModal Juez_id
   */
  function contraparteModal(){
      $('#modal2').openModal();
  }
  
  /**
   *
   * @param item
   * @returns {*}
   * @constructor
   */
  function FormatSelection(item) {
      return item.name;
  }
  
  /**
   *
   * @param item
   * @returns {string}
   * @constructor
   */
  function FormatResult(item) {
      var markup = "";
      if (item.name !== undefined) {
          markup += "<option value='" + item.id + "'>" + item.name + "</option>";
      }
      markup += "<a href=''>create</a>"
      return markup;
  }
  
  /**
   * Tribunal
   * @param item
   * @returns {string}
   * @constructor
   */
  function FormatNoResults(item){
      var markup = "";
      markup += "<a id='create-tribunal' class='modal-trigger' onclick='return tribunalModal()'>Nuevo registro</a>";
      return markup;
  }
  
  (function(){
  
      var tribunal = $("#tribunal_id");
  
      tribunal.select2({
          width: '100%',
          placeholder: "Selecione un Tribunal",
          allowClear: true,
          language: {
              noResults: FormatNoResults
          },
          ajax: {
              //quietMillis: 10,
              cache: true,
              dataType: 'json',
              type: 'GET',
              url: '/listados/tribunales/',//This asp.net mvc -> use your own URL
              results: function (data) {
                  return { results: data };
              }
          },
          formatResult: FormatResult,
          formatNoMatches:FormatNoResults,
          formatSelection: FormatSelection,
          escapeMarkup: function (markup) { return markup; }
      });
  
  })();
  
  /**
   * Juez_id
   * @param item
   * @returns {string}
   * @constructor
   */
  function FormatJuezNoResults(item){
      var markup = "";
      markup += "<a id='create-tribunal' class='modal-trigger' onclick='return juezModal()'>Nuevo registro</a>";
      return markup;
  }
  
  (function(){
      var juez = $("#juez_id");
  
      juez.select2({
          width: '100%',
          placeholder: "Selecione el juez responsable",
          allowClear: true,
          language: {
              noResults: FormatJuezNoResults
          },
          ajax: {
              cache: true,
              dataType: 'json',
              type: 'GET',
              url: '/listados/jueces/',//This asp.net mvc -> use your own URL
              results: function (data) {
                  return { results: data };
              }
          },
          formatResult: FormatResult,
          formatNoMatches:FormatJuezNoResults,
          formatSelection: FormatSelection,
          escapeMarkup: function (markup) { return markup; }
      });
  
  })();
  
  /**
   * contraparte
   * @param item
   * @returns {string}
   * @constructor
   */
  function FormatContraparteNoResults(item){
      var markup = "";
      markup += "<a id='create-tribunal' class='modal-trigger' onclick='return contraparteModal()'>Nuevo registro</a>";
      return markup;
  }
  
  (function(){
      var contraparte = $("#contraparte");
  
      contraparte.select2({
          width: '100%',
          placeholder: "Selecione contacto",
          allowClear: true,
          multiple: true,
          language: {
              noResults: FormatContraparteNoResults
          },
          ajax: {
              cache: true,
              dataType: 'json',
              type: 'GET',
              url: '/listados/contactos-caso/',
              results: function (data) {
                  return { results: data };
              }
          },
          formatResult: FormatResult,
          formatNoMatches:FormatContraparteNoResults,
          formatSelection: FormatSelection,
          escapeMarkup: function (markup) { return markup; }
      });
  
  })();
  
  (function(){
      var tercerias = $("#tercerias");
  
      tercerias.select2({
          width: '100%',
          placeholder: "Selecione contacto",
          allowClear: true,
          multiple: true,
          language: {
              noResults: FormatContraparteNoResults
          },
          ajax: {
              cache: true,
              dataType: 'json',
              type: 'GET',
              url: '/listados/contactos-caso/',
              results: function (data) {
                  return { results: data };
              }
          },
          formatResult: FormatResult,
          formatNoMatches:FormatContraparteNoResults,
          formatSelection: FormatSelection,
          escapeMarkup: function (markup) { return markup; }
      });
  
  })();
  
  /**
   * validacion
   * Tipo_casos -> Contraparte
   *
  **/
  
  $(document).ready(function() {
  
      $('#tipocaso_id').on('change', function(e){
          var num = $('#tipocaso_id option:selected').val();
          if(num == 1){
              $('#lcontraparte').text('Demandado(s)');
              $('#contraparte').prop("disabled", false);
              $('#contraparte').attr("name", 'demandados[]');
  
          }
          else if(num == 2){
              $('#lcontraparte').html('Demanadante(s)');
              $('#contraparte').prop("disabled", false);
              $('#contraparte').attr("name", 'demandantes[]');
          } else {
              $('#lcontraparte').html('N/A');
              $('#contraparte').prop("disabled", true);
          }
      });
  
      /**
       * habilitar cliente_id
       */
      $('#cliente_id').prop('disabled', true);
      $('#caso-number').keyup(function () {
          $('#cliente_id').prop('disabled', this.value == "" ? true : false);
      });
  
      /**
       * habilitar tipocaso_id
       */
      $('#tipocaso_id').prop('disabled', true);
      $('#cliente_id').change(function () {
          $('#tipocaso_id').prop('disabled', false);
      });
  
      /**
       * habiliar tipojuicio
       */
      $('#tipojuicio').prop('disabled', true);
      $('#tipocaso_id').on('change', function () {
          $('#tipojuicio').prop('disabled', false);
      });
  
      /**
       * habiliar instancia
       */
      $('#instancia').prop('disabled', true);
      $('#tipojuicio').on('change', function () {
          $('#instancia').prop('disabled', false);
      });
  
      /**
       * habilitar tribunal_id
       */
      $('#tribunal_id').prop('disabled', true);
      $('#instancia').keyup(function () {
          $('#tribunal_id').prop('disabled', this.value == "" ? true : false);
      });
  
      /**
       * habiliar salas_id
       */
      $('#salas_id').prop('disabled', true);
      $('#tribunal_id').on('change', function () {
          $('#salas_id').prop('disabled', false);
      });
  
      /**
       * habiliar juez_id
       */
      $('#juez_id').prop('disabled', true);
      $('#salas_id').on('change', function () {
          $('#juez_id').prop('disabled', false);
      });
  
      /**
       * habiliar juez_id
       */
      $('#submitCaso').prop('disabled', true);
      $('#honorarios').keyup(function () {
          $('#submitCaso').prop('disabled', this.value == "" ? true : false);
      });
  
  
  });
  
  /** Vue **/
  
  Vue.http.headers.common['X-CSRF-TOKEN'] = document.querySelector('#csrf-token').getAttribute('value');
  
  v = new Vue({
      el: '#create-casos',
      data:{
          newContacto:{
              id: '',
              type: '',
              name: '',
              cargo: '',
              phone: '',
              movil: '',
              email: '',
              notes: ''
          },
          newTribunal: {
              name:''
          }
      },
  
      methods:{
          /** cancelar contacto o juez **/
          modalJuezDestroy: function(){
              /** clear info **/
              this.newContacto.id = 0;
              this.newContacto.type = '';
              this.newContacto.name = '';
              this.newContacto.cargo = '';
              this.newContacto.phone = '';
              this.newContacto.movil = '';
              this.newContacto.email = '';
              this.newContacto.notes = '';
          },
  
          /** enviar juez **/
          submitJuezCreate: function(e){
              e.preventDefault();
              this.newContacto.type = 'Juez';
              $('#modal1').closeModal();
              var contactos = this.newContacto;
              this.$http.post('/contactos/', contactos).success(function (data, status, request) {
                  Materialize.toast('El conctacto a sido creado exitosamente!!!', 3000);
              }).error(function(data, status, response){
                  Materialize.toast('Hay un error en el envio de esta información!!!', 3000);
              });
  
              this.modalJuezDestroy();
          },
  
          /** destruir contacto **/
          modalContactDestroy: function(){
              this.newContacto = {};
          },
  
          /** enviar Contacto **/
          submitContactosCreate: function(e){
              e.preventDefault();
              this.newContacto.type = 'Relacionado a Caso';
              $('#modal2').closeModal();
              var contactos = this.newContacto;
              this.$http.post('/contactos/', contactos).success(function (data, status, request) {
                  Materialize.toast('El conctacto a sido creado exitosamente!!!', 3000);
              }).error(function(data, status, response){
                  Materialize.toast('Hay un error en el envio de esta información!!!', 3000);
              });
              this.modalContactDestroy();
          },
  
          /** Cancel create or edit **/
          modalTribunalDestroy: function(){
              this.newTribunal.name = '';
          },
  
          /** enviar Tribunal **/
          submitTribunalCreate: function(e){
              e.preventDefault();
              var tribunal = this.newTribunal;
              this.$http.post('/tribunal', tribunal).success(function (data, status, request) {
                  Materialize.toast('El Tribunal a sido agregado exitosamente!!!', 3000);
              }).error(function(data, status, response){
                  Materialize.toast('Hay un error en el envio de esta información!!!', 3000);
              });
              $('#modal3').closeModal();
              this.modalTribunalDestroy();
          }
  
      },
  
      computed: {
          JuezeditError: function(){
              if( ! this.newContacto.name) { return true }
              return false;
          }
      }
  });
  //# sourceMappingURL=vue-casos-create.js.map