text: /******/ (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) {
              Vue.url = __webpack_require__(1)(Vue);
              Vue.http = __webpack_require__(3)(Vue);
              Vue.resource = __webpack_require__(4)(Vue);
          }
  
          if (window.Vue) {
              Vue.use(install);
          }
  
          module.exports = install;
  
  
          /***/ },
      /* 1 */
      /***/ function(module, exports, __webpack_require__) {
  
          module.exports = function (Vue) {
  
              var _ = __webpack_require__(2)(Vue);
  
              /**
               * Url provides URL templating.
               *
               * @param {String} url
               * @param {Object} params
               */
  
              function Url (url, params) {
  
                  var urlParams = {}, queryParams = {}, options = url, query;
  
                  if (!_.isPlainObject(options)) {
                      options = {url: url, params: params};
                  }
  
                  options = _.extend({}, Url.options, _.options('url', this, options));
  
                  url = options.url.replace(/:([a-z]\w*)/gi, function (match, name) {
  
                      if (options.params[name]) {
                          urlParams[name] = true;
                          return encodeUriSegment(options.params[name]);
                      }
  
                      return '';
                  });
  
                  if (!url.match(/^(https?:)?\//) && options.root) {
                      url = options.root + '/' + url;
                  }
  
                  url = url.replace(/([^:])[\/]{2,}/g, '$1/');
                  url = url.replace(/(\w+)\/+$/, '$1');
  
                  _.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: '',
                  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) {
  
                  var pattern = new RegExp("^(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(?:\\?([^#]*))?(?:#(.*))?"),
                      matches = url.match(pattern);
  
                  return {
                      url: url,
                      scheme: matches[1] || '',
                      host: matches[2] || '',
                      path: matches[3] || '',
                      query: matches[4] || '',
                      fragment: matches[5] || ''
                  };
              };
  
              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' : '+'));
              }
  
              Object.defineProperty(Vue.prototype, '$url', {
  
                  get: function () {
                      return _.extend(Url.bind(this), Url);
                  }
  
              });
  
              return Url;
          };
  
  
          /***/ },
      /* 2 */
      /***/ function(module, exports, __webpack_require__) {
  
          /**
           * Utility functions.
           */
  
          module.exports = function (Vue) {
  
              var _ = Vue.util.extend({}, Vue.util);
  
              _.options = function (key, obj, options) {
  
                  var opts = obj.$options || {};
  
                  return _.extend({},
                      opts[key],
                      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];
                      }
                  }
              }
  
              _.isFunction = function (obj) {
                  return obj && typeof obj === 'function';
              };
  
              /**
               * Promise polyfill (https://gist.github.com/briancavalier/814313)
               */
  
              _.Promise = window.Promise;
  
              if (!_.Promise) {
  
                  _.Promise = function (executor) {
                      executor(this.resolve.bind(this), this.reject.bind(this));
                      this._thens = [];
                  };
  
                  _.Promise.prototype = {
  
                      then: function (onResolve, onReject, onProgress) {
                          this._thens.push({resolve: onResolve, reject: onReject, progress: onProgress});
                      },
  
                      'catch': function (onReject) {
                          this._thens.push({reject: onReject});
                      },
  
                      resolve: function (value) {
                          this._complete('resolve', value);
                      },
  
                      reject: function (reason) {
                          this._complete('reject', reason);
                      },
  
                      progress: function (status) {
  
                          var i = 0, aThen;
  
                          while (aThen = this._thens[i++]) {
                              aThen.progress && aThen.progress(status);
                          }
                      },
  
                      _complete: function (which, arg) {
  
                          this.then = which === 'resolve' ?
                              function (resolve, reject) { resolve && resolve(arg); } :
                              function (resolve, reject) { reject && reject(arg); };
  
                          this.resolve = this.reject = this.progress =
                              function () { throw new Error('Promise already completed.'); };
  
                          var aThen, i = 0;
  
                          while (aThen = this._thens[i++]) {
                              aThen[which] && aThen[which](arg);
                          }
  
                          delete this._thens;
                      }
                  };
              }
  
              return _;
          };
  
  
          /***/ },
      /* 3 */
      /***/ function(module, exports, __webpack_require__) {
  
          module.exports = function (Vue) {
  
              var _ = __webpack_require__(2)(Vue);
              var jsonType = { 'Content-Type': 'application/json;charset=utf-8' };
  
              /**
               * Http provides a service for sending XMLHttpRequests.
               */
  
              function Http (url, options) {
  
                  var self = this, headers, promise;
  
                  options = options || {};
  
                  if (_.isPlainObject(url)) {
                      options = url;
                      url = '';
                  }
  
                  headers = _.extend({},
                      Http.headers.common,
                      Http.headers[options.method.toLowerCase()]
                  );
  
                  options = _.extend(true, {url: url, headers: headers},
                      Http.options, _.options('http', this, options)
                  );
  
                  if (_.isObject(options.data) && /FormData/i.test(options.data.toString())) {
                      delete options.headers['Content-Type'];
                  }
  
                  promise = new _.Promise((options.method.toLowerCase() == 'jsonp' ? jsonp : xhr).bind(this, (this.$url || Vue.url), options));
  
                  _.extend(promise, {
  
                      success: function (onSuccess) {
  
                          this.then(function (request) {
                              onSuccess.apply(self, parseReq(request));
                          }, function () {});
  
                          return this;
                      },
  
                      error: function (onError) {
  
                          this.catch(function (request) {
                              onError.apply(self, parseReq(request));
                          });
  
                          return this;
                      },
  
                      always: function (onAlways) {
  
                          var cb = function (request) {
                              onAlways.apply(self, parseReq(request));
                          };
  
                          this.then(cb, cb);
  
                          return this;
                      }
  
                  });
  
                  if (options.success) {
                      promise.success(options.success);
                  }
  
                  if (options.error) {
                      promise.error(options.error);
                  }
  
                  return promise;
              }
  
              function xhr(url, options, resolve, reject) {
  
                  var request = new XMLHttpRequest();
  
                  if (_.isFunction(options.beforeSend)) {
                      options.beforeSend(request, options);
                  }
  
                  if (options.emulateHTTP && /^(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 = Vue.url.params(options.data);
                  }
  
                  if (_.isPlainObject(options.data)) {
                      options.data = JSON.stringify(options.data);
                  }
  
                  request.open(options.method, url(options), true);
  
                  _.each(options.headers, function (value, header) {
                      request.setRequestHeader(header, value);
                  });
  
                  request.onreadystatechange = function () {
  
                      if (this.readyState === 4) {
  
                          if (this.status >= 200 && this.status < 300) {
                              resolve(this);
                          } else {
                              reject(this);
                          }
                      }
                  };
  
                  request.send(options.data);
              }
  
              function jsonp(url, options, resolve, reject) {
  
                  var callback = '_jsonp' + Math.random().toString(36).substr(2), script, result;
  
                  _.extend(options.params, options.data);
                  options.params[options.jsonp] = callback;
  
                  if (_.isFunction(options.beforeSend)) {
                      options.beforeSend({}, options);
                  }
  
                  script = document.createElement('script');
                  script.src = url(options.url, options.params);
                  script.type = 'text/javascript';
                  script.async = true;
  
                  window[callback] = function (data) {
                      result = data;
                  };
  
                  var handler = function (event) {
  
                      delete window[callback];
                      document.body.removeChild(script);
  
                      if (event.type === 'load' && !result) {
                          event.type = 'error';
                      }
  
                      var text = result ? result : event.type, status = event.type === 'error' ? 404 : 200;
  
                      (status === 200 ? resolve : reject)({ responseText: text, status: status });
                  };
  
                  script.onload = handler;
                  script.onerror = handler;
  
                  document.body.appendChild(script);
              }
  
              function parseReq(request) {
  
                  var result;
  
                  try {
                      result = JSON.parse(request.responseText);
                  } catch (e) {
                      result = request.responseText;
                  }
  
                  return [result, request.status, request];
              }
  
              Http.options = {
                  method: 'GET',
                  params: {},
                  data: '',
                  jsonp: 'callback',
                  beforeSend: null,
                  emulateHTTP: false,
                  emulateJSON: false,
              };
  
              Http.headers = {
                  put: jsonType,
                  post: jsonType,
                  patch: jsonType,
                  delete: jsonType,
                  common: { 'Accept': 'application/json, text/plain, */*' }
              };
  
              ['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));
                  };
              });
  
              Object.defineProperty(Vue.prototype, '$http', {
  
                  get: function () {
                      return _.extend(Http.bind(this), Http);
                  }
  
              });
  
              return Http;
          };
  
  
          /***/ },
      /* 4 */
      /***/ function(module, exports, __webpack_require__) {
  
          module.exports = function (Vue) {
  
              var _ = __webpack_require__(2)(Vue);
  
              /**
               * Resource provides interaction support with RESTful services.
               */
  
              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 || Vue.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.url = action.url;
                  options.data = data;
                  options.params = _.extend({}, action.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'},
                  remove: {method: 'DELETE'},
                  delete: {method: 'DELETE'}
  
              };
  
              Object.defineProperty(Vue.prototype, '$resource', {
  
                  get: function () {
                      return Resource.bind(this);
                  }
  
              });
  
              return Resource;
          };
  
  
          /***/ }
      /******/ ]);