vuejs 1.0.25 → 1.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3cf999a581453ab61637b9fd0a201a59ee27de40
-  data.tar.gz: 056762dd930a7dc0b35562c3a709ec110669848d
+  metadata.gz: 68fd7b450826fa3f0fcb277942086fb1f8aa67e1
+  data.tar.gz: 720b4b56d10b9dc7baa772a835e8b6941bea379d
 SHA512:
-  metadata.gz: 4491279770eeda3b9b05ddd1ffa04808947cad984171d710d320c1f6900c095f85700c08576acaca5d300e3b912772e4881fe5dac784b7c2917238786139d8cb
-  data.tar.gz: 41b105e5f6587e8043b66ed449f72513c773d74ea1a5bd90cf50c66d4f6073c6b36e94dfa2f28bc4b38c40efa59919324e5f865d58d347a5dc7e6602664a2439
+  metadata.gz: da22388175330dda8df7daceab3561d0d34e8774cb9e3622a993ba57a32332bea77302fff2dc5dffc8319d92e90690b33c2f59f689d3f9272bf5b31f317f064c
+  data.tar.gz: 421c595d297b717a6d891134214ea1f831b27aa9bbb9ef8b7d11277b9e4a317459b5cb1b660fa89b6e7e5c1db208a66ebfee2e28e4b76ecf22f0103ba638b69b

data/README.md

@@ -2,7 +2,7 @@
 
 Vuejs ships with the latest [Vue.js + router + resource](http://vuejs.org/) and integrate with Rails' asset pipeline. Vue.js is created by Evan You.
 
-The current version is Vue.js (v1.0.24) + vue-router (v0.7.13) + vue-resource (v0.7.0)
+The current version is Vue.js (v1.0.24) + vue-router (v0.7.13) + vue-resource (v0.7.4)
 
 > Reactive Components for Modern Web Interfaces
 

data/lib/vuejs/version.rb

@@ -1,3 +1,3 @@
 module Vuejs
-  VERSION = "1.0.25"
+  VERSION = "1.0.26"
 end

data/vendor/assets/javascripts/vue-resource.js

@@ -1,1668 +1,1382 @@
-/**
- * vue-resource v0.7.2
+/*!
+ * vue-resource v0.7.4
  * 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 plugin(Vue) {
-
-	    if (plugin.installed) {
-	        return;
-	    }
-
-	    var _ = __webpack_require__(1);
-
-	    _.config = Vue.config;
-	    _.warning = Vue.util.warn;
-	    _.nextTick = Vue.util.nextTick;
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global.VueResource = factory());
+}(this, function () { 'use strict';
 
-	    Vue.url = __webpack_require__(2);
-	    Vue.http = __webpack_require__(8);
-	    Vue.resource = __webpack_require__(23);
-	    Vue.Promise = __webpack_require__(10);
+  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj;
+  };
 
-	    Object.defineProperties(Vue.prototype, {
+  /**
+   * Utility functions.
+   */
 
-	        $url: {
-	            get: function get() {
-	                return _.options(Vue.url, this, this.$options.url);
-	            }
-	        },
+  var util = {};
+  var config = {};
+  var array = [];
+  var console = window.console;
+  function Util (Vue) {
+      util = Vue.util;
+      config = Vue.config;
+  }
 
-	        $http: {
-	            get: function get() {
-	                return _.options(Vue.http, this, this.$options.http);
-	            }
-	        },
-
-	        $resource: {
-	            get: function get() {
-	                return Vue.resource.bind(this);
-	            }
-	        },
-
-	        $promise: {
-	            get: function get() {
-	                var _this = this;
-
-	                return function (executor) {
-	                    return new Vue.Promise(executor, _this);
-	                };
-	            }
-	        }
+  var isArray = Array.isArray;
+
+  function warn(msg) {
+      if (console && util.warn && (!config.silent || config.debug)) {
+          console.warn('[VueResource warn]: ' + msg);
+      }
+  }
+
+  function error(msg) {
+      if (console) {
+          console.error(msg);
+      }
+  }
+
+  function nextTick(cb, ctx) {
+      return util.nextTick(cb, ctx);
+  }
+
+  function trim(str) {
+      return str.replace(/^\s*|\s*$/g, '');
+  }
+
+  function toLower(str) {
+      return str ? str.toLowerCase() : '';
+  }
+
+  function isString(val) {
+      return typeof val === 'string';
+  }
+
+  function isFunction(val) {
+      return typeof val === 'function';
+  }
+
+  function isObject(obj) {
+      return obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object';
+  }
+
+  function isPlainObject(obj) {
+      return isObject(obj) && Object.getPrototypeOf(obj) == Object.prototype;
+  }
 
-	    });
-	}
+  function options(fn, obj, opts) {
 
-	if (typeof window !== 'undefined' && window.Vue) {
-	    window.Vue.use(plugin);
-	}
+      opts = opts || {};
 
-	module.exports = plugin;
+      if (isFunction(opts)) {
+          opts = opts.call(obj);
+      }
 
-/***/ },
-/* 1 */
-/***/ function(module, exports) {
+      return merge(fn.bind({ $vm: obj, $options: opts }), fn, { $options: opts });
+  }
 
-	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+  function each(obj, iterator) {
 
-	/**
-	 * Utility functions.
-	 */
+      var i, key;
 
-	var _ = exports,
-	    array = [],
-	    console = window.console;
+      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);
+              }
+          }
+      }
 
-	_.warn = function (msg) {
-	    if (console && _.warning && (!_.config.silent || _.config.debug)) {
-	        console.warn('[VueResource warn]: ' + msg);
-	    }
-	};
+      return obj;
+  }
 
-	_.error = function (msg) {
-	    if (console) {
-	        console.error(msg);
-	    }
-	};
+  function extend(target) {
 
-	_.trim = function (str) {
-	    return str.replace(/^\s*|\s*$/g, '');
-	};
-
-	_.toLower = function (str) {
-	    return str ? str.toLowerCase() : '';
-	};
-
-	_.isArray = Array.isArray;
+      var args = array.slice.call(arguments, 1);
 
-	_.isString = function (val) {
-	    return typeof val === 'string';
-	};
+      args.forEach(function (arg) {
+          _merge(target, arg);
+      });
 
-	_.isFunction = function (val) {
-	    return typeof val === 'function';
-	};
+      return target;
+  }
 
-	_.isObject = function (obj) {
-	    return obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object';
-	};
+  function merge(target) {
 
-	_.isPlainObject = function (obj) {
-	    return _.isObject(obj) && Object.getPrototypeOf(obj) == Object.prototype;
-	};
+      var args = array.slice.call(arguments, 1);
 
-	_.options = function (fn, obj, options) {
+      args.forEach(function (arg) {
+          _merge(target, arg, true);
+      });
 
-	    options = options || {};
+      return target;
+  }
 
-	    if (_.isFunction(options)) {
-	        options = options.call(obj);
-	    }
+  function _merge(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] = [];
+              }
+              _merge(target[key], source[key], deep);
+          } else if (source[key] !== undefined) {
+              target[key] = source[key];
+          }
+      }
+  }
 
-	    return _.merge(fn.bind({ $vm: obj, $options: options }), fn, { $options: options });
-	};
+  function root (options, next) {
 
-	_.each = function (obj, iterator) {
+      var url = next(options);
 
-	    var i, key;
+      if (isString(options.root) && !url.match(/^(https?:)?\//)) {
+          url = options.root + '/' + url;
+      }
 
-	    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 url;
+  }
 
-	    return obj;
-	};
+  function query (options, next) {
 
-	_.defaults = function (target, source) {
+      var urlParams = Object.keys(Url.options.params),
+          query = {},
+          url = next(options);
 
-	    for (var key in source) {
-	        if (target[key] === undefined) {
-	            target[key] = source[key];
-	        }
-	    }
+      each(options.params, function (value, key) {
+          if (urlParams.indexOf(key) === -1) {
+              query[key] = value;
+          }
+      });
 
-	    return target;
-	};
+      query = Url.params(query);
 
-	_.extend = function (target) {
+      if (query) {
+          url += (url.indexOf('?') == -1 ? '?' : '&') + query;
+      }
 
-	    var args = array.slice.call(arguments, 1);
+      return url;
+  }
 
-	    args.forEach(function (arg) {
-	        merge(target, arg);
-	    });
+  function legacy (options, next) {
 
-	    return target;
-	};
+      var variables = [],
+          url = next(options);
 
-	_.merge = function (target) {
+      url = url.replace(/(\/?):([a-z]\w*)/gi, function (match, slash, name) {
 
-	    var args = array.slice.call(arguments, 1);
+          warn('The `:' + name + '` parameter syntax has been deprecated. Use the `{' + name + '}` syntax instead.');
 
-	    args.forEach(function (arg) {
-	        merge(target, arg, true);
-	    });
+          if (options.params[name]) {
+              variables.push(name);
+              return slash + encodeUriSegment(options.params[name]);
+          }
 
-	    return target;
-	};
+          return '';
+      });
 
-	function merge(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] = [];
-	            }
-	            merge(target[key], source[key], deep);
-	        } else if (source[key] !== undefined) {
-	            target[key] = source[key];
-	        }
-	    }
-	}
+      variables.forEach(function (key) {
+          delete options.params[key];
+      });
 
-/***/ },
-/* 2 */
-/***/ function(module, exports, __webpack_require__) {
+      return url;
+  }
 
-	/**
-	 * Service for URL templating.
-	 */
+  function encodeUriSegment(value) {
 
-	var _ = __webpack_require__(1);
-	var ie = document.documentMode;
-	var el = document.createElement('a');
+      return encodeUriQuery(value, true).replace(/%26/gi, '&').replace(/%3D/gi, '=').replace(/%2B/gi, '+');
+  }
 
-	function Url(url, params) {
+  function encodeUriQuery(value, spaces) {
 
-	    var options = url,
-	        transform;
+      return encodeURIComponent(value).replace(/%40/gi, '@').replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, spaces ? '%20' : '+');
+  }
 
-	    if (_.isString(url)) {
-	        options = { url: url, params: params };
-	    }
+  /**
+   * URL Template v2.0.6 (https://github.com/bramstein/url-template)
+   */
+
+  function expand(url, params, variables) {
+
+      var tmpl = parse(url),
+          expanded = tmpl.expand(params);
+
+      if (variables) {
+          variables.push.apply(variables, tmpl.vars);
+      }
+
+      return expanded;
+  }
+
+  function parse(template) {
+
+      var operators = ['+', '#', '.', '/', ';', '?', '&'],
+          variables = [];
+
+      return {
+          vars: variables,
+          expand: function expand(context) {
+              return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
+                  if (expression) {
+
+                      var operator = null,
+                          values = [];
+
+                      if (operators.indexOf(expression.charAt(0)) !== -1) {
+                          operator = expression.charAt(0);
+                          expression = expression.substr(1);
+                      }
+
+                      expression.split(/,/g).forEach(function (variable) {
+                          var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
+                          values.push.apply(values, getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
+                          variables.push(tmp[1]);
+                      });
+
+                      if (operator && operator !== '+') {
+
+                          var separator = ',';
+
+                          if (operator === '?') {
+                              separator = '&';
+                          } else if (operator !== '#') {
+                              separator = operator;
+                          }
+
+                          return (values.length !== 0 ? operator : '') + values.join(separator);
+                      } else {
+                          return values.join(',');
+                      }
+                  } else {
+                      return encodeReserved(literal);
+                  }
+              });
+          }
+      };
+  }
+
+  function getValues(context, operator, key, modifier) {
+
+      var value = context[key],
+          result = [];
+
+      if (isDefined(value) && value !== '') {
+          if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+              value = value.toString();
+
+              if (modifier && modifier !== '*') {
+                  value = value.substring(0, parseInt(modifier, 10));
+              }
+
+              result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));
+          } else {
+              if (modifier === '*') {
+                  if (Array.isArray(value)) {
+                      value.filter(isDefined).forEach(function (value) {
+                          result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null));
+                      });
+                  } else {
+                      Object.keys(value).forEach(function (k) {
+                          if (isDefined(value[k])) {
+                              result.push(encodeValue(operator, value[k], k));
+                          }
+                      });
+                  }
+              } else {
+                  var tmp = [];
+
+                  if (Array.isArray(value)) {
+                      value.filter(isDefined).forEach(function (value) {
+                          tmp.push(encodeValue(operator, value));
+                      });
+                  } else {
+                      Object.keys(value).forEach(function (k) {
+                          if (isDefined(value[k])) {
+                              tmp.push(encodeURIComponent(k));
+                              tmp.push(encodeValue(operator, value[k].toString()));
+                          }
+                      });
+                  }
+
+                  if (isKeyOperator(operator)) {
+                      result.push(encodeURIComponent(key) + '=' + tmp.join(','));
+                  } else if (tmp.length !== 0) {
+                      result.push(tmp.join(','));
+                  }
+              }
+          }
+      } else {
+          if (operator === ';') {
+              result.push(encodeURIComponent(key));
+          } else if (value === '' && (operator === '&' || operator === '?')) {
+              result.push(encodeURIComponent(key) + '=');
+          } else if (value === '') {
+              result.push('');
+          }
+      }
+
+      return result;
+  }
+
+  function isDefined(value) {
+      return value !== undefined && value !== null;
+  }
+
+  function isKeyOperator(operator) {
+      return operator === ';' || operator === '&' || operator === '?';
+  }
+
+  function encodeValue(operator, value, key) {
+
+      value = operator === '+' || operator === '#' ? encodeReserved(value) : encodeURIComponent(value);
+
+      if (key) {
+          return encodeURIComponent(key) + '=' + value;
+      } else {
+          return value;
+      }
+  }
+
+  function encodeReserved(str) {
+      return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {
+          if (!/%[0-9A-Fa-f]/.test(part)) {
+              part = encodeURI(part);
+          }
+          return part;
+      }).join('');
+  }
+
+  function template (options) {
+
+      var variables = [],
+          url = expand(options.url, options.params, variables);
+
+      variables.forEach(function (key) {
+          delete options.params[key];
+      });
+
+      return url;
+  }
+
+  /**
+   * Service for URL templating.
+   */
+
+  var ie = document.documentMode;
+  var el = document.createElement('a');
+
+  function Url(url, params) {
+
+      var self = this || {},
+          options = url,
+          transform;
+
+      if (isString(url)) {
+          options = { url: url, params: params };
+      }
+
+      options = merge({}, Url.options, self.$options, options);
+
+      Url.transforms.forEach(function (handler) {
+          transform = factory(handler, transform, self.$vm);
+      });
+
+      return transform(options);
+  }
+
+  /**
+   * Url options.
+   */
+
+  Url.options = {
+      url: '',
+      root: null,
+      params: {}
+  };
+
+  /**
+   * Url transforms.
+   */
+
+  Url.transforms = [template, legacy, query, root];
+
+  /**
+   * Encodes a Url parameter string.
+   *
+   * @param {Object} obj
+   */
 
-	    options = _.merge({}, Url.options, this.$options, options);
+  Url.params = function (obj) {
 
-	    Url.transforms.forEach(function (handler) {
-	        transform = factory(handler, transform, this.$vm);
-	    }, this);
+      var params = [],
+          escape = encodeURIComponent;
 
-	    return transform(options);
-	};
+      params.add = function (key, value) {
 
-	/**
-	 * Url options.
-	 */
+          if (isFunction(value)) {
+              value = value();
+          }
 
-	Url.options = {
-	    url: '',
-	    root: null,
-	    params: {}
-	};
+          if (value === null) {
+              value = '';
+          }
 
-	/**
-	 * Url transforms.
-	 */
+          this.push(escape(key) + '=' + escape(value));
+      };
+
+      serialize(params, obj);
 
-	Url.transforms = [__webpack_require__(3), __webpack_require__(5), __webpack_require__(6), __webpack_require__(7)];
+      return params.join('&').replace(/%20/g, '+');
+  };
+
+  /**
+   * Parse a URL and return its components.
+   *
+   * @param {String} url
+   */
+
+  Url.parse = function (url) {
+
+      if (ie) {
+          el.href = url;
+          url = el.href;
+      }
+
+      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 factory(handler, next, vm) {
+      return function (options) {
+          return handler.call(vm, options, next);
+      };
+  }
+
+  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);
+          }
+      });
+  }
+
+  /**
+   * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)
+   */
+
+  var RESOLVED = 0;
+  var REJECTED = 1;
+  var PENDING = 2;
+
+  function Promise$2(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$2.reject = function (r) {
+      return new Promise$2(function (resolve, reject) {
+          reject(r);
+      });
+  };
+
+  Promise$2.resolve = function (x) {
+      return new Promise$2(function (resolve, reject) {
+          resolve(x);
+      });
+  };
+
+  Promise$2.all = function all(iterable) {
+      return new Promise$2(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) {
+              Promise$2.resolve(iterable[i]).then(resolver(i), reject);
+          }
+      });
+  };
+
+  Promise$2.race = function race(iterable) {
+      return new Promise$2(function (resolve, reject) {
+          for (var i = 0; i < iterable.length; i += 1) {
+              Promise$2.resolve(iterable[i]).then(resolve, reject);
+          }
+      });
+  };
+
+  var p$1 = Promise$2.prototype;
+
+  p$1.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 === 'undefined' ? 'undefined' : _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$1.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$1.notify = function notify() {
+      var promise = this;
+
+      nextTick(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$1.then = function then(onResolved, onRejected) {
+      var promise = this;
+
+      return new Promise$2(function (resolve, reject) {
+          promise.deferred.push([onResolved, onRejected, resolve, reject]);
+          promise.notify();
+      });
+  };
+
+  p$1.catch = function (onRejected) {
+      return this.then(undefined, onRejected);
+  };
+
+  var PromiseObj = window.Promise || Promise$2;
+
+  function Promise$1(executor, context) {
+
+      if (executor instanceof PromiseObj) {
+          this.promise = executor;
+      } else {
+          this.promise = new PromiseObj(executor.bind(context));
+      }
+
+      this.context = context;
+  }
+
+  Promise$1.all = function (iterable, context) {
+      return new Promise$1(PromiseObj.all(iterable), context);
+  };
+
+  Promise$1.resolve = function (value, context) {
+      return new Promise$1(PromiseObj.resolve(value), context);
+  };
+
+  Promise$1.reject = function (reason, context) {
+      return new Promise$1(PromiseObj.reject(reason), context);
+  };
+
+  Promise$1.race = function (iterable, context) {
+      return new Promise$1(PromiseObj.race(iterable), context);
+  };
+
+  var p = Promise$1.prototype;
 
-	/**
-	 * Encodes a Url parameter string.
-	 *
-	 * @param {Object} obj
-	 */
+  p.bind = function (context) {
+      this.context = context;
+      return this;
+  };
 
-	Url.params = function (obj) {
+  p.then = function (fulfilled, rejected) {
 
-	    var params = [],
-	        escape = encodeURIComponent;
+      if (fulfilled && fulfilled.bind && this.context) {
+          fulfilled = fulfilled.bind(this.context);
+      }
 
-	    params.add = function (key, value) {
+      if (rejected && rejected.bind && this.context) {
+          rejected = rejected.bind(this.context);
+      }
 
-	        if (_.isFunction(value)) {
-	            value = value();
-	        }
+      this.promise = this.promise.then(fulfilled, rejected);
 
-	        if (value === null) {
-	            value = '';
-	        }
+      return this;
+  };
 
-	        this.push(escape(key) + '=' + escape(value));
-	    };
+  p.catch = function (rejected) {
 
-	    serialize(params, obj);
+      if (rejected && rejected.bind && this.context) {
+          rejected = rejected.bind(this.context);
+      }
 
-	    return params.join('&').replace(/%20/g, '+');
-	};
+      this.promise = this.promise.catch(rejected);
 
-	/**
-	 * Parse a URL and return its components.
-	 *
-	 * @param {String} url
-	 */
+      return this;
+  };
 
-	Url.parse = function (url) {
+  p.finally = function (callback) {
 
-	    if (ie) {
-	        el.href = url;
-	        url = el.href;
-	    }
+      return this.then(function (value) {
+          callback.call(this);
+          return value;
+      }, function (reason) {
+          callback.call(this);
+          return PromiseObj.reject(reason);
+      });
+  };
 
-	    el.href = url;
+  p.success = function (callback) {
 
-	    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(/^#/, '') : ''
-	    };
-	};
+      warn('The `success` method has been deprecated. Use the `then` method instead.');
 
-	function factory(handler, next, vm) {
-	    return function (options) {
-	        return handler.call(vm, options, next);
-	    };
-	}
+      return this.then(function (response) {
+          return callback.call(this, response.data, response.status, response) || response;
+      });
+  };
 
-	function serialize(params, obj, scope) {
+  p.error = function (callback) {
 
-	    var array = _.isArray(obj),
-	        plain = _.isPlainObject(obj),
-	        hash;
+      warn('The `error` method has been deprecated. Use the `catch` method instead.');
 
-	    _.each(obj, function (value, key) {
+      return this.catch(function (response) {
+          return callback.call(this, response.data, response.status, response) || response;
+      });
+  };
 
-	        hash = _.isObject(value) || _.isArray(value);
+  p.always = function (callback) {
 
-	        if (scope) {
-	            key = scope + '[' + (plain || hash ? key : '') + ']';
-	        }
+      warn('The `always` method has been deprecated. Use the `finally` method instead.');
 
-	        if (!scope && array) {
-	            params.add(value.name, value.value);
-	        } else if (hash) {
-	            serialize(params, value, key);
-	        } else {
-	            params.add(key, value);
-	        }
-	    });
-	}
+      var cb = function cb(response) {
+          return callback.call(this, response.data, response.status, response) || response;
+      };
 
-	module.exports = _.url = Url;
+      return this.then(cb, cb);
+  };
 
-/***/ },
-/* 3 */
-/***/ function(module, exports, __webpack_require__) {
+  function xdrClient (request) {
+      return new Promise$1(function (resolve) {
 
-	/**
-	 * URL Template (RFC 6570) Transform.
-	 */
+          var xdr = new XDomainRequest(),
+              response = { request: request },
+              handler;
 
-	var UrlTemplate = __webpack_require__(4);
+          request.cancel = function () {
+              xdr.abort();
+          };
 
-	module.exports = function (options) {
+          xdr.open(request.method, Url(request), true);
 
-	    var variables = [],
-	        url = UrlTemplate.expand(options.url, options.params, variables);
-
-	    variables.forEach(function (key) {
-	        delete options.params[key];
-	    });
-
-	    return url;
-	};
-
-/***/ },
-/* 4 */
-/***/ function(module, exports) {
-
-	/**
-	 * URL Template v2.0.6 (https://github.com/bramstein/url-template)
-	 */
-
-	exports.expand = function (url, params, variables) {
-
-	    var tmpl = this.parse(url),
-	        expanded = tmpl.expand(params);
-
-	    if (variables) {
-	        variables.push.apply(variables, tmpl.vars);
-	    }
-
-	    return expanded;
-	};
-
-	exports.parse = function (template) {
-
-	    var operators = ['+', '#', '.', '/', ';', '?', '&'],
-	        variables = [];
-
-	    return {
-	        vars: variables,
-	        expand: function expand(context) {
-	            return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
-	                if (expression) {
-
-	                    var operator = null,
-	                        values = [];
-
-	                    if (operators.indexOf(expression.charAt(0)) !== -1) {
-	                        operator = expression.charAt(0);
-	                        expression = expression.substr(1);
-	                    }
-
-	                    expression.split(/,/g).forEach(function (variable) {
-	                        var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
-	                        values.push.apply(values, exports.getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
-	                        variables.push(tmp[1]);
-	                    });
-
-	                    if (operator && operator !== '+') {
-
-	                        var separator = ',';
-
-	                        if (operator === '?') {
-	                            separator = '&';
-	                        } else if (operator !== '#') {
-	                            separator = operator;
-	                        }
-
-	                        return (values.length !== 0 ? operator : '') + values.join(separator);
-	                    } else {
-	                        return values.join(',');
-	                    }
-	                } else {
-	                    return exports.encodeReserved(literal);
-	                }
-	            });
-	        }
-	    };
-	};
-
-	exports.getValues = function (context, operator, key, modifier) {
-
-	    var value = context[key],
-	        result = [];
-
-	    if (this.isDefined(value) && value !== '') {
-	        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-	            value = value.toString();
-
-	            if (modifier && modifier !== '*') {
-	                value = value.substring(0, parseInt(modifier, 10));
-	            }
-
-	            result.push(this.encodeValue(operator, value, this.isKeyOperator(operator) ? key : null));
-	        } else {
-	            if (modifier === '*') {
-	                if (Array.isArray(value)) {
-	                    value.filter(this.isDefined).forEach(function (value) {
-	                        result.push(this.encodeValue(operator, value, this.isKeyOperator(operator) ? key : null));
-	                    }, this);
-	                } else {
-	                    Object.keys(value).forEach(function (k) {
-	                        if (this.isDefined(value[k])) {
-	                            result.push(this.encodeValue(operator, value[k], k));
-	                        }
-	                    }, this);
-	                }
-	            } else {
-	                var tmp = [];
-
-	                if (Array.isArray(value)) {
-	                    value.filter(this.isDefined).forEach(function (value) {
-	                        tmp.push(this.encodeValue(operator, value));
-	                    }, this);
-	                } else {
-	                    Object.keys(value).forEach(function (k) {
-	                        if (this.isDefined(value[k])) {
-	                            tmp.push(encodeURIComponent(k));
-	                            tmp.push(this.encodeValue(operator, value[k].toString()));
-	                        }
-	                    }, this);
-	                }
-
-	                if (this.isKeyOperator(operator)) {
-	                    result.push(encodeURIComponent(key) + '=' + tmp.join(','));
-	                } else if (tmp.length !== 0) {
-	                    result.push(tmp.join(','));
-	                }
-	            }
-	        }
-	    } else {
-	        if (operator === ';') {
-	            result.push(encodeURIComponent(key));
-	        } else if (value === '' && (operator === '&' || operator === '?')) {
-	            result.push(encodeURIComponent(key) + '=');
-	        } else if (value === '') {
-	            result.push('');
-	        }
-	    }
-
-	    return result;
-	};
-
-	exports.isDefined = function (value) {
-	    return value !== undefined && value !== null;
-	};
-
-	exports.isKeyOperator = function (operator) {
-	    return operator === ';' || operator === '&' || operator === '?';
-	};
-
-	exports.encodeValue = function (operator, value, key) {
-
-	    value = operator === '+' || operator === '#' ? this.encodeReserved(value) : encodeURIComponent(value);
-
-	    if (key) {
-	        return encodeURIComponent(key) + '=' + value;
-	    } else {
-	        return value;
-	    }
-	};
-
-	exports.encodeReserved = function (str) {
-	    return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {
-	        if (!/%[0-9A-Fa-f]/.test(part)) {
-	            part = encodeURI(part);
-	        }
-	        return part;
-	    }).join('');
-	};
-
-/***/ },
-/* 5 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Legacy Transform.
-	 */
-
-	var _ = __webpack_require__(1);
-
-	module.exports = function (options, next) {
-
-	    var variables = [],
-	        url = next(options);
-
-	    url = url.replace(/(\/?):([a-z]\w*)/gi, function (match, slash, name) {
-
-	        _.warn('The `:' + name + '` parameter syntax has been deprecated. Use the `{' + name + '}` syntax instead.');
-
-	        if (options.params[name]) {
-	            variables.push(name);
-	            return slash + encodeUriSegment(options.params[name]);
-	        }
-
-	        return '';
-	    });
-
-	    variables.forEach(function (key) {
-	        delete options.params[key];
-	    });
-
-	    return url;
-	};
+          handler = function handler(event) {
 
-	function encodeUriSegment(value) {
+              response.data = xdr.responseText;
+              response.status = xdr.status;
+              response.statusText = xdr.statusText || '';
 
-	    return encodeUriQuery(value, true).replace(/%26/gi, '&').replace(/%3D/gi, '=').replace(/%2B/gi, '+');
-	}
+              resolve(response);
+          };
 
-	function encodeUriQuery(value, spaces) {
+          xdr.timeout = 0;
+          xdr.onload = handler;
+          xdr.onabort = handler;
+          xdr.onerror = handler;
+          xdr.ontimeout = function () {};
+          xdr.onprogress = function () {};
 
-	    return encodeURIComponent(value).replace(/%40/gi, '@').replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, spaces ? '%20' : '+');
-	}
+          xdr.send(request.data);
+      });
+  }
 
-/***/ },
-/* 6 */
-/***/ function(module, exports, __webpack_require__) {
+  var originUrl = Url.parse(location.href);
+  var supportCors = 'withCredentials' in new XMLHttpRequest();
 
-	/**
-	 * Query Parameter Transform.
-	 */
+  var exports$1 = {
+      request: function request(_request) {
 
-	var _ = __webpack_require__(1);
+          if (_request.crossOrigin === null) {
+              _request.crossOrigin = crossOrigin(_request);
+          }
 
-	module.exports = function (options, next) {
+          if (_request.crossOrigin) {
 
-	    var urlParams = Object.keys(_.url.options.params),
-	        query = {},
-	        url = next(options);
+              if (!supportCors) {
+                  _request.client = xdrClient;
+              }
 
-	    _.each(options.params, function (value, key) {
-	        if (urlParams.indexOf(key) === -1) {
-	            query[key] = value;
-	        }
-	    });
+              _request.emulateHTTP = false;
+          }
 
-	    query = _.url.params(query);
+          return _request;
+      }
+  };
 
-	    if (query) {
-	        url += (url.indexOf('?') == -1 ? '?' : '&') + query;
-	    }
+  function crossOrigin(request) {
 
-	    return url;
-	};
+      var requestUrl = Url.parse(Url(request));
 
-/***/ },
-/* 7 */
-/***/ function(module, exports, __webpack_require__) {
+      return requestUrl.protocol !== originUrl.protocol || requestUrl.host !== originUrl.host;
+  }
 
-	/**
-	 * Root Prefix Transform.
-	 */
+  var exports$2 = {
+      request: function request(_request) {
 
-	var _ = __webpack_require__(1);
+          if (_request.emulateJSON && isPlainObject(_request.data)) {
+              _request.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+              _request.data = Url.params(_request.data);
+          }
 
-	module.exports = function (options, next) {
+          if (isObject(_request.data) && /FormData/i.test(_request.data.toString())) {
+              delete _request.headers['Content-Type'];
+          }
 
-	    var url = next(options);
+          if (isPlainObject(_request.data)) {
+              _request.data = JSON.stringify(_request.data);
+          }
 
-	    if (_.isString(options.root) && !url.match(/^(https?:)?\//)) {
-	        url = options.root + '/' + url;
-	    }
+          return _request;
+      },
+      response: function response(_response) {
 
-	    return url;
-	};
+          try {
+              _response.data = JSON.parse(_response.data);
+          } catch (e) {}
 
-/***/ },
-/* 8 */
-/***/ function(module, exports, __webpack_require__) {
+          return _response;
+      }
+  };
 
-	/**
-	 * Service for sending network requests.
-	 */
+  function jsonpClient (request) {
+      return new Promise$1(function (resolve) {
 
-	var _ = __webpack_require__(1);
-	var Client = __webpack_require__(9);
-	var Promise = __webpack_require__(10);
-	var interceptor = __webpack_require__(13);
-	var jsonType = { 'Content-Type': 'application/json' };
+          var callback = '_jsonp' + Math.random().toString(36).substr(2),
+              response = { request: request, data: null },
+              handler,
+              script;
 
-	function Http(url, options) {
-	    var _this = this;
+          request.params[request.jsonp] = callback;
+          request.cancel = function () {
+              handler({ type: 'cancel' });
+          };
 
-	    var client = Client,
-	        request,
-	        promise;
+          script = document.createElement('script');
+          script.src = Url(request);
+          script.type = 'text/javascript';
+          script.async = true;
 
-	    Http.interceptors.forEach(function (handler) {
-	        client = interceptor(handler, _this.$vm)(client);
-	    });
+          window[callback] = function (data) {
+              response.data = data;
+          };
 
-	    options = _.isObject(url) ? url : _.extend({ url: url }, options);
-	    request = _.merge({}, Http.options, this.$options, options);
-	    promise = client(request).bind(this.$vm).then(function (response) {
+          handler = function handler(event) {
 
-	        return response.ok ? response : Promise.reject(response);
-	    }, function (response) {
+              if (event.type === 'load' && response.data !== null) {
+                  response.status = 200;
+              } else if (event.type === 'error') {
+                  response.status = 404;
+              } else {
+                  response.status = 0;
+              }
 
-	        if (response instanceof Error) {
-	            _.error(response);
-	        }
+              resolve(response);
 
-	        return Promise.reject(response);
-	    });
+              delete window[callback];
+              document.body.removeChild(script);
+          };
 
-	    if (request.success) {
-	        promise.success(request.success);
-	    }
+          script.onload = handler;
+          script.onerror = handler;
 
-	    if (request.error) {
-	        promise.error(request.error);
-	    }
+          document.body.appendChild(script);
+      });
+  }
 
-	    return promise;
-	}
+  var exports$3 = {
+      request: function request(_request) {
 
-	Http.options = {
-	    method: 'get',
-	    data: '',
-	    params: {},
-	    headers: {},
-	    xhr: null,
-	    upload: null,
-	    jsonp: 'callback',
-	    beforeSend: null,
-	    crossOrigin: null,
-	    emulateHTTP: false,
-	    emulateJSON: false,
-	    timeout: 0
-	};
+          if (_request.method == 'JSONP') {
+              _request.client = jsonpClient;
+          }
 
-	Http.interceptors = [__webpack_require__(14), __webpack_require__(15), __webpack_require__(16), __webpack_require__(18), __webpack_require__(19), __webpack_require__(20), __webpack_require__(21)];
+          return _request;
+      }
+  };
 
-	Http.headers = {
-	    put: jsonType,
-	    post: jsonType,
-	    patch: jsonType,
-	    delete: jsonType,
-	    common: { 'Accept': 'application/json, text/plain, */*' },
-	    custom: { 'X-Requested-With': 'XMLHttpRequest' }
-	};
+  var exports$4 = {
+      request: function request(_request) {
 
-	['get', 'put', 'post', 'patch', 'delete', 'jsonp'].forEach(function (method) {
+          if (isFunction(_request.beforeSend)) {
+              _request.beforeSend.call(this, _request);
+          }
 
-	    Http[method] = function (url, data, success, options) {
+          return _request;
+      }
+  };
 
-	        if (_.isFunction(data)) {
-	            options = success;
-	            success = data;
-	            data = undefined;
-	        }
+  /**
+   * HTTP method override Interceptor.
+   */
 
-	        if (_.isObject(success)) {
-	            options = success;
-	            success = undefined;
-	        }
+  var exports$5 = {
+      request: function request(_request) {
 
-	        return this(url, _.extend({ method: method, data: data, success: success }, options));
-	    };
-	});
+          if (_request.emulateHTTP && /^(PUT|PATCH|DELETE)$/i.test(_request.method)) {
+              _request.headers['X-HTTP-Method-Override'] = _request.method;
+              _request.method = 'POST';
+          }
 
-	module.exports = _.http = Http;
+          return _request;
+      }
+  };
 
-/***/ },
-/* 9 */
-/***/ function(module, exports, __webpack_require__) {
+  var exports$6 = {
+      request: function request(_request) {
 
-	/**
-	 * Base client.
-	 */
+          _request.method = _request.method.toUpperCase();
+          _request.headers = extend({}, Http.headers.common, !_request.crossOrigin ? Http.headers.custom : {}, Http.headers[_request.method.toLowerCase()], _request.headers);
 
-	var _ = __webpack_require__(1);
-	var Promise = __webpack_require__(10);
-	var xhrClient = __webpack_require__(12);
+          if (isPlainObject(_request.data) && /^(GET|JSONP)$/i.test(_request.method)) {
+              extend(_request.params, _request.data);
+              delete _request.data;
+          }
 
-	module.exports = function (request) {
+          return _request;
+      }
+  };
 
-	    var response = (request.client || xhrClient)(request);
+  /**
+   * Timeout Interceptor.
+   */
 
-	    return Promise.resolve(response).then(function (response) {
+  var exports$7 = function exports() {
 
-	        if (response.headers) {
+      var timeout;
 
-	            var headers = parseHeaders(response.headers);
+      return {
+          request: function request(_request) {
 
-	            response.headers = function (name) {
+              if (_request.timeout) {
+                  timeout = setTimeout(function () {
+                      _request.cancel();
+                  }, _request.timeout);
+              }
 
-	                if (name) {
-	                    return headers[_.toLower(name)];
-	                }
+              return _request;
+          },
+          response: function response(_response) {
 
-	                return headers;
-	            };
-	        }
+              clearTimeout(timeout);
 
-	        response.ok = response.status >= 200 && response.status < 300;
+              return _response;
+          }
+      };
+  };
 
-	        return response;
-	    });
-	};
+  function interceptor (handler, vm) {
 
-	function parseHeaders(str) {
+      return function (client) {
 
-	    var headers = {},
-	        value,
-	        name,
-	        i;
+          if (isFunction(handler)) {
+              handler = handler.call(vm, Promise$1);
+          }
 
-	    if (_.isString(str)) {
-	        _.each(str.split('\n'), function (row) {
+          return function (request) {
 
-	            i = row.indexOf(':');
-	            name = _.trim(_.toLower(row.slice(0, i)));
-	            value = _.trim(row.slice(i + 1));
+              if (isFunction(handler.request)) {
+                  request = handler.request.call(vm, request);
+              }
 
-	            if (headers[name]) {
+              return when(request, function (request) {
+                  return when(client(request), function (response) {
 
-	                if (_.isArray(headers[name])) {
-	                    headers[name].push(value);
-	                } else {
-	                    headers[name] = [headers[name], value];
-	                }
-	            } else {
+                      if (isFunction(handler.response)) {
+                          response = handler.response.call(vm, response);
+                      }
 
-	                headers[name] = value;
-	            }
-	        });
-	    }
+                      return response;
+                  });
+              });
+          };
+      };
+  }
 
-	    return headers;
-	}
+  function when(value, fulfilled, rejected) {
 
-/***/ },
-/* 10 */
-/***/ function(module, exports, __webpack_require__) {
+      var promise = Promise$1.resolve(value);
 
-	/**
-	 * Promise adapter.
-	 */
+      if (arguments.length < 2) {
+          return promise;
+      }
 
-	var _ = __webpack_require__(1);
-	var PromiseObj = window.Promise || __webpack_require__(11);
+      return promise.then(fulfilled, rejected);
+  }
 
-	function Promise(executor, context) {
+  function xhrClient (request) {
+      return new Promise$1(function (resolve) {
 
-	    if (executor instanceof PromiseObj) {
-	        this.promise = executor;
-	    } else {
-	        this.promise = new PromiseObj(executor.bind(context));
-	    }
+          var xhr = new XMLHttpRequest(),
+              response = { request: request },
+              handler;
 
-	    this.context = context;
-	}
+          request.cancel = function () {
+              xhr.abort();
+          };
 
-	Promise.all = function (iterable, context) {
-	    return new Promise(PromiseObj.all(iterable), context);
-	};
+          xhr.open(request.method, Url(request), true);
 
-	Promise.resolve = function (value, context) {
-	    return new Promise(PromiseObj.resolve(value), context);
-	};
+          handler = function handler(event) {
 
-	Promise.reject = function (reason, context) {
-	    return new Promise(PromiseObj.reject(reason), context);
-	};
+              response.data = 'response' in xhr ? xhr.response : xhr.responseText;
+              response.status = xhr.status === 1223 ? 204 : xhr.status; // IE9 status bug
+              response.statusText = trim(xhr.statusText || '');
+              response.headers = xhr.getAllResponseHeaders();
 
-	Promise.race = function (iterable, context) {
-	    return new Promise(PromiseObj.race(iterable), context);
-	};
+              resolve(response);
+          };
 
-	var p = Promise.prototype;
+          xhr.timeout = 0;
+          xhr.onload = handler;
+          xhr.onabort = handler;
+          xhr.onerror = handler;
+          xhr.ontimeout = function () {};
+          xhr.onprogress = function () {};
 
-	p.bind = function (context) {
-	    this.context = context;
-	    return this;
-	};
+          if (isPlainObject(request.xhr)) {
+              extend(xhr, request.xhr);
+          }
 
-	p.then = function (fulfilled, rejected) {
+          if (isPlainObject(request.upload)) {
+              extend(xhr.upload, request.upload);
+          }
 
-	    if (fulfilled && fulfilled.bind && this.context) {
-	        fulfilled = fulfilled.bind(this.context);
-	    }
+          each(request.headers || {}, function (value, header) {
+              xhr.setRequestHeader(header, value);
+          });
 
-	    if (rejected && rejected.bind && this.context) {
-	        rejected = rejected.bind(this.context);
-	    }
+          xhr.send(request.data);
+      });
+  }
 
-	    this.promise = this.promise.then(fulfilled, rejected);
+  function Client (request) {
 
-	    return this;
-	};
+      var response = (request.client || xhrClient)(request);
 
-	p.catch = function (rejected) {
+      return Promise$1.resolve(response).then(function (response) {
 
-	    if (rejected && rejected.bind && this.context) {
-	        rejected = rejected.bind(this.context);
-	    }
+          if (response.headers) {
 
-	    this.promise = this.promise.catch(rejected);
+              var headers = parseHeaders(response.headers);
 
-	    return this;
-	};
+              response.headers = function (name) {
 
-	p.finally = function (callback) {
+                  if (name) {
+                      return headers[toLower(name)];
+                  }
 
-	    return this.then(function (value) {
-	        callback.call(this);
-	        return value;
-	    }, function (reason) {
-	        callback.call(this);
-	        return PromiseObj.reject(reason);
-	    });
-	};
+                  return headers;
+              };
+          }
 
-	p.success = function (callback) {
+          response.ok = response.status >= 200 && response.status < 300;
 
-	    _.warn('The `success` method has been deprecated. Use the `then` method instead.');
+          return response;
+      });
+  }
 
-	    return this.then(function (response) {
-	        return callback.call(this, response.data, response.status, response) || response;
-	    });
-	};
+  function parseHeaders(str) {
 
-	p.error = function (callback) {
+      var headers = {},
+          value,
+          name,
+          i;
 
-	    _.warn('The `error` method has been deprecated. Use the `catch` method instead.');
+      if (isString(str)) {
+          each(str.split('\n'), function (row) {
 
-	    return this.catch(function (response) {
-	        return callback.call(this, response.data, response.status, response) || response;
-	    });
-	};
+              i = row.indexOf(':');
+              name = trim(toLower(row.slice(0, i)));
+              value = trim(row.slice(i + 1));
 
-	p.always = function (callback) {
+              if (headers[name]) {
 
-	    _.warn('The `always` method has been deprecated. Use the `finally` method instead.');
+                  if (isArray(headers[name])) {
+                      headers[name].push(value);
+                  } else {
+                      headers[name] = [headers[name], value];
+                  }
+              } else {
 
-	    var cb = function cb(response) {
-	        return callback.call(this, response.data, response.status, response) || response;
-	    };
+                  headers[name] = value;
+              }
+          });
+      }
 
-	    return this.then(cb, cb);
-	};
+      return headers;
+  }
 
-	module.exports = Promise;
+  /**
+   * Service for sending network requests.
+   */
 
-/***/ },
-/* 11 */
-/***/ function(module, exports, __webpack_require__) {
+  var jsonType = { 'Content-Type': 'application/json' };
 
-	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+  function Http(url, options) {
 
-	/**
-	 * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)
-	 */
+      var self = this || {},
+          client = Client,
+          request,
+          promise;
 
-	var _ = __webpack_require__(1);
+      Http.interceptors.forEach(function (handler) {
+          client = interceptor(handler, self.$vm)(client);
+      });
 
-	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) {
-	            Promise.resolve(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) {
-	            Promise.resolve(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 === 'undefined' ? 'undefined' : _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;
-
-	    _.nextTick(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.then = function then(onResolved, onRejected) {
-	    var promise = this;
-
-	    return new Promise(function (resolve, reject) {
-	        promise.deferred.push([onResolved, onRejected, resolve, reject]);
-	        promise.notify();
-	    });
-	};
-
-	p.catch = function (onRejected) {
-	    return this.then(undefined, onRejected);
-	};
-
-	module.exports = Promise;
-
-/***/ },
-/* 12 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * XMLHttp client.
-	 */
-
-	var _ = __webpack_require__(1);
-	var Promise = __webpack_require__(10);
-
-	module.exports = function (request) {
-	    return new Promise(function (resolve) {
-
-	        var xhr = new XMLHttpRequest(),
-	            response = { request: request },
-	            handler;
-
-	        request.cancel = function () {
-	            xhr.abort();
-	        };
-
-	        xhr.open(request.method, _.url(request), true);
-
-	        handler = function handler(event) {
-
-	            response.data = xhr.responseText;
-	            response.status = xhr.status;
-	            response.statusText = xhr.statusText;
-	            response.headers = xhr.getAllResponseHeaders();
+      options = isObject(url) ? url : extend({ url: url }, options);
+      request = merge({}, Http.options, self.$options, options);
+      promise = client(request).bind(self.$vm).then(function (response) {
 
-	            resolve(response);
-	        };
+          return response.ok ? response : Promise$1.reject(response);
+      }, function (response) {
 
-	        xhr.timeout = 0;
-	        xhr.onload = handler;
-	        xhr.onabort = handler;
-	        xhr.onerror = handler;
-	        xhr.ontimeout = function () {};
-	        xhr.onprogress = function () {};
+          if (response instanceof Error) {
+              error(response);
+          }
 
-	        if (_.isPlainObject(request.xhr)) {
-	            _.extend(xhr, request.xhr);
-	        }
+          return Promise$1.reject(response);
+      });
 
-	        if (_.isPlainObject(request.upload)) {
-	            _.extend(xhr.upload, request.upload);
-	        }
+      if (request.success) {
+          promise.success(request.success);
+      }
 
-	        _.each(request.headers || {}, function (value, header) {
-	            xhr.setRequestHeader(header, value);
-	        });
+      if (request.error) {
+          promise.error(request.error);
+      }
 
-	        xhr.send(request.data);
-	    });
-	};
+      return promise;
+  }
 
-/***/ },
-/* 13 */
-/***/ function(module, exports, __webpack_require__) {
+  Http.options = {
+      method: 'get',
+      data: '',
+      params: {},
+      headers: {},
+      xhr: null,
+      upload: null,
+      jsonp: 'callback',
+      beforeSend: null,
+      crossOrigin: null,
+      emulateHTTP: false,
+      emulateJSON: false,
+      timeout: 0
+  };
 
-	/**
-	 * Interceptor factory.
-	 */
+  Http.headers = {
+      put: jsonType,
+      post: jsonType,
+      patch: jsonType,
+      delete: jsonType,
+      common: { 'Accept': 'application/json, text/plain, */*' },
+      custom: { 'X-Requested-With': 'XMLHttpRequest' }
+  };
 
-	var _ = __webpack_require__(1);
-	var Promise = __webpack_require__(10);
+  Http.interceptors = [exports$4, exports$7, exports$3, exports$5, exports$2, exports$6, exports$1];
 
-	module.exports = function (handler, vm) {
+  ['get', 'put', 'post', 'patch', 'delete', 'jsonp'].forEach(function (method) {
 
-	    return function (client) {
+      Http[method] = function (url, data, success, options) {
 
-	        if (_.isFunction(handler)) {
-	            handler = handler.call(vm, Promise);
-	        }
+          if (isFunction(data)) {
+              options = success;
+              success = data;
+              data = undefined;
+          }
 
-	        return function (request) {
+          if (isObject(success)) {
+              options = success;
+              success = undefined;
+          }
 
-	            if (_.isFunction(handler.request)) {
-	                request = handler.request.call(vm, request);
-	            }
+          return this(url, extend({ method: method, data: data, success: success }, options));
+      };
+  });
 
-	            return when(request, function (request) {
-	                return when(client(request), function (response) {
+  function Resource(url, params, actions, options) {
 
-	                    if (_.isFunction(handler.response)) {
-	                        response = handler.response.call(vm, response);
-	                    }
+      var self = this || {},
+          resource = {};
 
-	                    return response;
-	                });
-	            });
-	        };
-	    };
-	};
+      actions = extend({}, Resource.actions, actions);
 
-	function when(value, fulfilled, rejected) {
+      each(actions, function (action, name) {
 
-	    var promise = Promise.resolve(value);
+          action = merge({ url: url, params: params || {} }, options, action);
 
-	    if (arguments.length < 2) {
-	        return promise;
-	    }
+          resource[name] = function () {
+              return (self.$http || Http)(opts(action, arguments));
+          };
+      });
 
-	    return promise.then(fulfilled, rejected);
-	}
+      return resource;
+  }
 
-/***/ },
-/* 14 */
-/***/ function(module, exports, __webpack_require__) {
+  function opts(action, args) {
 
-	/**
-	 * Before Interceptor.
-	 */
+      var options = extend({}, action),
+          params = {},
+          data,
+          success,
+          error;
 
-	var _ = __webpack_require__(1);
+      switch (args.length) {
 
-	module.exports = {
+          case 4:
 
-	    request: function request(_request) {
+              error = args[3];
+              success = args[2];
 
-	        if (_.isFunction(_request.beforeSend)) {
-	            _request.beforeSend.call(this, _request);
-	        }
+          case 3:
+          case 2:
 
-	        return _request;
-	    }
+              if (isFunction(args[1])) {
 
-	};
+                  if (isFunction(args[0])) {
 
-/***/ },
-/* 15 */
-/***/ function(module, exports) {
+                      success = args[0];
+                      error = args[1];
 
-	/**
-	 * Timeout Interceptor.
-	 */
+                      break;
+                  }
 
-	module.exports = function () {
+                  success = args[1];
+                  error = args[2];
+              } else {
 
-	    var timeout;
+                  params = args[0];
+                  data = args[1];
+                  success = args[2];
 
-	    return {
+                  break;
+              }
 
-	        request: function request(_request) {
+          case 1:
 
-	            if (_request.timeout) {
-	                timeout = setTimeout(function () {
-	                    _request.cancel();
-	                }, _request.timeout);
-	            }
+              if (isFunction(args[0])) {
+                  success = args[0];
+              } else if (/^(POST|PUT|PATCH)$/i.test(options.method)) {
+                  data = args[0];
+              } else {
+                  params = args[0];
+              }
 
-	            return _request;
-	        },
+              break;
 
-	        response: function response(_response) {
+          case 0:
 
-	            clearTimeout(timeout);
+              break;
 
-	            return _response;
-	        }
+          default:
 
-	    };
-	};
+              throw 'Expected up to 4 arguments [params, data, success, error], got ' + args.length + ' arguments';
+      }
 
-/***/ },
-/* 16 */
-/***/ function(module, exports, __webpack_require__) {
+      options.data = data;
+      options.params = extend({}, options.params, params);
 
-	/**
-	 * JSONP Interceptor.
-	 */
+      if (success) {
+          options.success = success;
+      }
 
-	var jsonpClient = __webpack_require__(17);
+      if (error) {
+          options.error = error;
+      }
 
-	module.exports = {
+      return options;
+  }
 
-	    request: function request(_request) {
+  Resource.actions = {
 
-	        if (_request.method == 'JSONP') {
-	            _request.client = jsonpClient;
-	        }
+      get: { method: 'GET' },
+      save: { method: 'POST' },
+      query: { method: 'GET' },
+      update: { method: 'PUT' },
+      remove: { method: 'DELETE' },
+      delete: { method: 'DELETE' }
 
-	        return _request;
-	    }
+  };
 
-	};
+  function plugin(Vue) {
 
-/***/ },
-/* 17 */
-/***/ function(module, exports, __webpack_require__) {
+      if (plugin.installed) {
+          return;
+      }
 
-	/**
-	 * JSONP client.
-	 */
+      Util(Vue);
 
-	var _ = __webpack_require__(1);
-	var Promise = __webpack_require__(10);
+      Vue.url = Url;
+      Vue.http = Http;
+      Vue.resource = Resource;
+      Vue.Promise = Promise$1;
 
-	module.exports = function (request) {
-	    return new Promise(function (resolve) {
+      Object.defineProperties(Vue.prototype, {
 
-	        var callback = '_jsonp' + Math.random().toString(36).substr(2),
-	            response = { request: request, data: null },
-	            handler,
-	            script;
+          $url: {
+              get: function get() {
+                  return options(Vue.url, this, this.$options.url);
+              }
+          },
 
-	        request.params[request.jsonp] = callback;
-	        request.cancel = function () {
-	            handler({ type: 'cancel' });
-	        };
+          $http: {
+              get: function get() {
+                  return options(Vue.http, this, this.$options.http);
+              }
+          },
 
-	        script = document.createElement('script');
-	        script.src = _.url(request);
-	        script.type = 'text/javascript';
-	        script.async = true;
+          $resource: {
+              get: function get() {
+                  return Vue.resource.bind(this);
+              }
+          },
 
-	        window[callback] = function (data) {
-	            response.data = data;
-	        };
+          $promise: {
+              get: function get() {
+                  var _this = this;
 
-	        handler = function handler(event) {
+                  return function (executor) {
+                      return new Vue.Promise(executor, _this);
+                  };
+              }
+          }
 
-	            if (event.type === 'load' && response.data !== null) {
-	                response.status = 200;
-	            } else if (event.type === 'error') {
-	                response.status = 404;
-	            } else {
-	                response.status = 0;
-	            }
+      });
+  }
 
-	            resolve(response);
+  if (typeof window !== 'undefined' && window.Vue) {
+      window.Vue.use(plugin);
+  }
 
-	            delete window[callback];
-	            document.body.removeChild(script);
-	        };
+  return plugin;
 
-	        script.onload = handler;
-	        script.onerror = handler;
-
-	        document.body.appendChild(script);
-	    });
-	};
-
-/***/ },
-/* 18 */
-/***/ function(module, exports) {
-
-	/**
-	 * HTTP method override Interceptor.
-	 */
-
-	module.exports = {
-
-	    request: function request(_request) {
-
-	        if (_request.emulateHTTP && /^(PUT|PATCH|DELETE)$/i.test(_request.method)) {
-	            _request.headers['X-HTTP-Method-Override'] = _request.method;
-	            _request.method = 'POST';
-	        }
-
-	        return _request;
-	    }
-
-	};
-
-/***/ },
-/* 19 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Mime Interceptor.
-	 */
-
-	var _ = __webpack_require__(1);
-
-	module.exports = {
-
-	    request: function request(_request) {
-
-	        if (_request.emulateJSON && _.isPlainObject(_request.data)) {
-	            _request.headers['Content-Type'] = 'application/x-www-form-urlencoded';
-	            _request.data = _.url.params(_request.data);
-	        }
-
-	        if (_.isObject(_request.data) && /FormData/i.test(_request.data.toString())) {
-	            delete _request.headers['Content-Type'];
-	        }
-
-	        if (_.isPlainObject(_request.data)) {
-	            _request.data = JSON.stringify(_request.data);
-	        }
-
-	        return _request;
-	    },
-
-	    response: function response(_response) {
-
-	        try {
-	            _response.data = JSON.parse(_response.data);
-	        } catch (e) {}
-
-	        return _response;
-	    }
-
-	};
-
-/***/ },
-/* 20 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Header Interceptor.
-	 */
-
-	var _ = __webpack_require__(1);
-
-	module.exports = {
-
-	    request: function request(_request) {
-
-	        _request.method = _request.method.toUpperCase();
-	        _request.headers = _.extend({}, _.http.headers.common, !_request.crossOrigin ? _.http.headers.custom : {}, _.http.headers[_request.method.toLowerCase()], _request.headers);
-
-	        if (_.isPlainObject(_request.data) && /^(GET|JSONP)$/i.test(_request.method)) {
-	            _.extend(_request.params, _request.data);
-	            delete _request.data;
-	        }
-
-	        return _request;
-	    }
-
-	};
-
-/***/ },
-/* 21 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * CORS Interceptor.
-	 */
-
-	var _ = __webpack_require__(1);
-	var xdrClient = __webpack_require__(22);
-	var xhrCors = 'withCredentials' in new XMLHttpRequest();
-	var originUrl = _.url.parse(location.href);
-
-	module.exports = {
-
-	    request: function request(_request) {
-
-	        if (_request.crossOrigin === null) {
-	            _request.crossOrigin = crossOrigin(_request);
-	        }
-
-	        if (_request.crossOrigin) {
-
-	            if (!xhrCors) {
-	                _request.client = xdrClient;
-	            }
-
-	            _request.emulateHTTP = false;
-	        }
-
-	        return _request;
-	    }
-
-	};
-
-	function crossOrigin(request) {
-
-	    var requestUrl = _.url.parse(_.url(request));
-
-	    return requestUrl.protocol !== originUrl.protocol || requestUrl.host !== originUrl.host;
-	}
-
-/***/ },
-/* 22 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * XDomain client (Internet Explorer).
-	 */
-
-	var _ = __webpack_require__(1);
-	var Promise = __webpack_require__(10);
-
-	module.exports = function (request) {
-	    return new Promise(function (resolve) {
-
-	        var xdr = new XDomainRequest(),
-	            response = { request: request },
-	            handler;
-
-	        request.cancel = function () {
-	            xdr.abort();
-	        };
-
-	        xdr.open(request.method, _.url(request), true);
-
-	        handler = function handler(event) {
-
-	            response.data = xdr.responseText;
-	            response.status = xdr.status;
-	            response.statusText = xdr.statusText;
-
-	            resolve(response);
-	        };
-
-	        xdr.timeout = 0;
-	        xdr.onload = handler;
-	        xdr.onabort = handler;
-	        xdr.onerror = handler;
-	        xdr.ontimeout = function () {};
-	        xdr.onprogress = function () {};
-
-	        xdr.send(request.data);
-	    });
-	};
-
-/***/ },
-/* 23 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Service for interacting with RESTful services.
-	 */
-
-	var _ = __webpack_require__(1);
-
-	function Resource(url, params, actions, options) {
-
-	    var self = this,
-	        resource = {};
-
-	    actions = _.extend({}, Resource.actions, actions);
-
-	    _.each(actions, function (action, name) {
-
-	        action = _.merge({ url: url, params: params || {} }, options, 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' }
-
-	};
-
-	module.exports = _.resource = Resource;
-
-/***/ }
-/******/ ])
-});
-;
+}));