vuejs-rails 1.0.4 → 1.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 652e1bf18c147ff425bb80bcf926d99fec92fe19
-  data.tar.gz: 8ecc9c6186aca2d9dfacae834e76f1d3b2389c05
+  metadata.gz: e174ae583339c6007caf8ffdf834c9ad8610dbce
+  data.tar.gz: 4f23d0e8167cf6100179dfab9a27d70bb70fb53d
 SHA512:
-  metadata.gz: 1a7861fd6bc86684780a13058974cf1477067a7094d2a73ca56ac3442fade37889e9d89ab2d0d205a3aa4af12dfdd99f127b6fb2ffb90c75e7edb840582c7ae8
-  data.tar.gz: a3236a3e9f553c3ac41ab4ca347d7fe9cf4f7b51ea96c5ed78b65d635e54005ca2c68f276a68d8aa4db1ffb1174b32da1f9298eb5a6d11d6aa356defdf52639a
+  metadata.gz: 5e5e62bb2ebe40a7e79e92e9973cd3d40316d82bac922a1d443ea3eb4d81cc2e5f15013f29cef8c1a316a03112d20d9130307affb91369d9361fc6c760bde6da
+  data.tar.gz: a326fa7b3db116e0a0e66478e04972836b92971184579a1683d2c231b3bbc45cb32ff0299eeda2f1c0733997ecee67ccdcfbe818975aa59195f6e951e7db24ff

data/lib/vuejs-rails/version.rb

@@ -1,5 +1,5 @@
 module Vue
   module Rails
-    VERSION = '1.0.4'
+    VERSION = '1.0.16'
   end
 end

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

@@ -1,5 +1,5 @@
 /**
- * vue-resource v0.1.16
+ * vue-resource v0.7.0
  * https://github.com/vuejs/vue-resource
  * Released under the MIT License.
  */
@@ -8,7 +8,7 @@
 	if(typeof exports === 'object' && typeof module === 'object')
 		module.exports = factory();
 	else if(typeof define === 'function' && define.amd)
-		define(factory);
+		define([], factory);
 	else if(typeof exports === 'object')
 		exports["VueResource"] = factory();
 	else
@@ -66,23 +66,28 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	function install(Vue) {
 
-	    var _ = __webpack_require__(1)(Vue);
+	    var _ = __webpack_require__(1);
 
-	    Vue.url = __webpack_require__(2)(_);
-	    Vue.http = __webpack_require__(3)(_);
-	    Vue.resource = __webpack_require__(7)(_);
+	    _.config = Vue.config;
+	    _.warning = Vue.util.warn;
+	    _.nextTick = Vue.util.nextTick;
+
+	    Vue.url = __webpack_require__(2);
+	    Vue.http = __webpack_require__(8);
+	    Vue.resource = __webpack_require__(23);
+	    Vue.Promise = __webpack_require__(10);
 
 	    Object.defineProperties(Vue.prototype, {
 
 	        $url: {
 	            get: function () {
-	                return this._url || (this._url = _.options(Vue.url, this, this.$options.url));
+	                return _.options(Vue.url, this, this.$options.url);
 	            }
 	        },
 
 	        $http: {
 	            get: function () {
-	                return this._http || (this._http = _.options(Vue.http, this, this.$options.http));
+	                return _.options(Vue.http, this, this.$options.http);
 	            }
 	        },
 
@@ -90,6 +95,14 @@ return /******/ (function(modules) { // webpackBootstrap
 	            get: function () {
 	                return Vue.resource.bind(this);
 	            }
+	        },
+
+	        $promise: {
+	            get: function () {
+	                return function (executor) {
+	                    return new Vue.Promise(executor, this);
+	                }.bind(this);
+	            }
 	        }
 
 	    });
@@ -101,6 +114,7 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	module.exports = install;
 
+
 /***/ },
 /* 1 */
 /***/ function(module, exports) {
@@ -109,478 +123,844 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * Utility functions.
 	 */
 
-	module.exports = function (Vue) {
+	var _ = exports, array = [], console = window.console;
 
-	    var _ = Vue.util.extend({}, Vue.util);
+	_.warn = function (msg) {
+	    if (console && _.warning && (!_.config.silent || _.config.debug)) {
+	        console.warn('[VueResource warn]: ' + msg);
+	    }
+	};
 
-	    _.isString = function (value) {
-	        return typeof value === 'string';
-	    };
+	_.error = function (msg) {
+	    if (console) {
+	        console.error(msg);
+	    }
+	};
 
-	    _.isFunction = function (value) {
-	        return typeof value === 'function';
-	    };
+	_.trim = function (str) {
+	    return str.replace(/^\s*|\s*$/g, '');
+	};
 
-	    _.options = function (fn, obj, options) {
+	_.toLower = function (str) {
+	    return str ? str.toLowerCase() : '';
+	};
 
-	        options = options || {};
+	_.isArray = Array.isArray;
 
-	        if (_.isFunction(options)) {
-	            options = options.call(obj);
-	        }
+	_.isString = function (val) {
+	    return typeof val === 'string';
+	};
 
-	        return _.extend(fn.bind({vm: obj, options: options}), fn, {options: options});
-	    };
+	_.isFunction = function (val) {
+	    return typeof val === 'function';
+	};
 
-	    _.each = function (obj, iterator) {
+	_.isObject = function (obj) {
+	    return obj !== null && typeof obj === 'object';
+	};
 
-	        var i, key;
+	_.isPlainObject = function (obj) {
+	    return _.isObject(obj) && Object.getPrototypeOf(obj) == Object.prototype;
+	};
 
-	        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);
-	                }
-	            }
-	        }
+	_.options = function (fn, obj, options) {
 
-	        return obj;
-	    };
+	    options = options || {};
 
-	    _.extend = function (target) {
+	    if (_.isFunction(options)) {
+	        options = options.call(obj);
+	    }
+
+	    return _.merge(fn.bind({$vm: obj, $options: options}), fn, {$options: options});
+	};
 
-	        var array = [], args = array.slice.call(arguments, 1), deep;
+	_.each = function (obj, iterator) {
 
-	        if (typeof target == 'boolean') {
-	            deep = target;
-	            target = args.shift();
+	    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);
+	            }
+	        }
+	    }
 
-	        args.forEach(function (arg) {
-	            extend(target, arg, deep);
-	        });
+	    return obj;
+	};
 
-	        return target;
-	    };
+	_.defaults = function (target, source) {
 
-	    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];
-	            }
+	    for (var key in source) {
+	        if (target[key] === undefined) {
+	            target[key] = source[key];
 	        }
 	    }
 
-	    return _;
+	    return target;
+	};
+
+	_.extend = function (target) {
+
+	    var args = array.slice.call(arguments, 1);
+
+	    args.forEach(function (arg) {
+	        merge(target, arg);
+	    });
+
+	    return target;
+	};
+
+	_.merge = function (target) {
+
+	    var args = array.slice.call(arguments, 1);
+
+	    args.forEach(function (arg) {
+	        merge(target, arg, true);
+	    });
+
+	    return target;
 	};
 
+	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];
+	        }
+	    }
+	}
+
 
 /***/ },
 /* 2 */
-/***/ function(module, exports) {
+/***/ function(module, exports, __webpack_require__) {
 
 	/**
 	 * Service for URL templating.
 	 */
 
+	var _ = __webpack_require__(1);
 	var ie = document.documentMode;
 	var el = document.createElement('a');
 
-	module.exports = function (_) {
+	function Url(url, params) {
 
-	    function Url(url, params) {
+	    var options = url, transform;
 
-	        var urlParams = {}, queryParams = {}, options = url, query;
+	    if (_.isString(url)) {
+	        options = {url: url, params: params};
+	    }
 
-	        if (!_.isPlainObject(options)) {
-	            options = {url: url, params: params};
-	        }
+	    options = _.merge({}, Url.options, this.$options, options);
 
-	        options = _.extend(true, {},
-	            Url.options, this.options, options
-	        );
+	    Url.transforms.forEach(function (handler) {
+	        transform = factory(handler, transform, this.$vm);
+	    }, this);
 
-	        url = options.url.replace(/(\/?):([a-z]\w*)/gi, function (match, slash, name) {
+	    return transform(options);
+	};
 
-	            if (options.params[name]) {
-	                urlParams[name] = true;
-	                return slash + encodeUriSegment(options.params[name]);
-	            }
+	/**
+	 * Url options.
+	 */
 
-	            return '';
-	        });
+	Url.options = {
+	    url: '',
+	    root: null,
+	    params: {}
+	};
 
-	        if (_.isString(options.root) && !url.match(/^(https?:)?\//)) {
-	            url = options.root + '/' + url;
-	        }
+	/**
+	 * Url transforms.
+	 */
 
-	        _.each(options.params, function (value, key) {
-	            if (!urlParams[key]) {
-	                queryParams[key] = value;
-	            }
-	        });
+	Url.transforms = [
+	    __webpack_require__(3),
+	    __webpack_require__(5),
+	    __webpack_require__(6),
+	    __webpack_require__(7)
+	];
+
+	/**
+	 * Encodes a Url parameter string.
+	 *
+	 * @param {Object} obj
+	 */
+
+	Url.params = function (obj) {
+
+	    var params = [], escape = encodeURIComponent;
+
+	    params.add = function (key, value) {
 
-	        query = Url.params(queryParams);
+	        if (_.isFunction(value)) {
+	            value = value();
+	        }
 
-	        if (query) {
-	            url += (url.indexOf('?') == -1 ? '?' : '&') + query;
+	        if (value === null) {
+	            value = '';
 	        }
 
-	        return url;
+	        this.push(escape(key) + '=' + escape(value));
+	    };
+
+	    serialize(params, obj);
+
+	    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;
 	    }
 
-	    /**
-	     * Url options.
-	     */
+	    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(/^#/, '') : ''
+	    };
+	};
 
-	    Url.options = {
-	        url: '',
-	        root: null,
-	        params: {}
+	function factory(handler, next, vm) {
+	    return function (options) {
+	        return handler.call(vm, options, next);
 	    };
+	}
 
-	    /**
-	     * Encodes a Url parameter string.
-	     *
-	     * @param {Object} obj
-	     */
+	function serialize(params, obj, scope) {
 
-	    Url.params = function (obj) {
+	    var array = _.isArray(obj), plain = _.isPlainObject(obj), hash;
 
-	        var params = [];
+	    _.each(obj, function (value, key) {
 
-	        params.add = function (key, value) {
+	        hash = _.isObject(value) || _.isArray(value);
 
-	            if (_.isFunction (value)) {
-	                value = value();
-	            }
+	        if (scope) {
+	            key = scope + '[' + (plain || hash ? key : '') + ']';
+	        }
 
-	            if (value === null) {
-	                value = '';
-	            }
+	        if (!scope && array) {
+	            params.add(value.name, value.value);
+	        } else if (hash) {
+	            serialize(params, value, key);
+	        } else {
+	            params.add(key, value);
+	        }
+	    });
+	}
 
-	            this.push(encodeUriSegment(key) + '=' + encodeUriSegment(value));
-	        };
+	module.exports = _.url = Url;
 
-	        serialize(params, obj);
 
-	        return params.join('&');
-	    };
+/***/ },
+/* 3 */
+/***/ function(module, exports, __webpack_require__) {
 
-	    /**
-	     * Parse a URL and return its components.
-	     *
-	     * @param {String} url
-	     */
+	/**
+	 * URL Template (RFC 6570) Transform.
+	 */
 
-	    Url.parse = function (url) {
+	var UrlTemplate = __webpack_require__(4);
 
-	        if (ie) {
-	            el.href = url;
-	            url = el.href;
-	        }
+	module.exports = function (options) {
 
-	        el.href = url;
+	    var variables = [], url = UrlTemplate.expand(options.url, options.params, variables);
 
-	        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(/^#/, '') : ''
-	        };
-	    };
+	    variables.forEach(function (key) {
+	        delete options.params[key];
+	    });
+
+	    return url;
+	};
+
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
 
-	    function serialize(params, obj, scope) {
+	/**
+	 * 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 = [];
 
-	        var array = _.isArray(obj), plain = _.isPlainObject(obj), hash;
+	    return {
+	        vars: variables,
+	        expand: function (context) {
+	            return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
+	                if (expression) {
 
-	        _.each(obj, function (value, key) {
+	                    var operator = null, values = [];
 
-	            hash = _.isObject(value) || _.isArray(value);
+	                    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(',');
+	                    }
 
-	            if (scope) {
-	                key = scope + '[' + (plain || hash ? key : '') + ']';
+	                } 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));
 	            }
 
-	            if (!scope && array) {
-	                params.add(value.name, value.value);
-	            } else if (hash) {
-	                serialize(params, value, key);
+	            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 {
-	                params.add(key, value);
+	                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('');
+	        }
 	    }
 
-	    function encodeUriSegment(value) {
+	    return result;
+	};
 
-	        return encodeUriQuery(value, true).
-	            replace(/%26/gi, '&').
-	            replace(/%3D/gi, '=').
-	            replace(/%2B/gi, '+');
-	    }
+	exports.isDefined = function (value) {
+	    return value !== undefined && value !== null;
+	};
+
+	exports.isKeyOperator = function (operator) {
+	    return operator === ';' || operator === '&' || operator === '?';
+	};
 
-	    function encodeUriQuery(value, spaces) {
+	exports.encodeValue = function (operator, value, key) {
 
-	        return encodeURIComponent(value).
-	            replace(/%40/gi, '@').
-	            replace(/%3A/gi, ':').
-	            replace(/%24/g, '$').
-	            replace(/%2C/gi, ',').
-	            replace(/%20/g, (spaces ? '%20' : '+'));
+	    value = (operator === '+' || operator === '#') ? this.encodeReserved(value) : encodeURIComponent(value);
+
+	    if (key) {
+	        return encodeURIComponent(key) + '=' + value;
+	    } else {
+	        return value;
 	    }
+	};
 
-	    return _.url = Url;
+	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('');
 	};
 
 
 /***/ },
-/* 3 */
+/* 5 */
 /***/ function(module, exports, __webpack_require__) {
 
 	/**
-	 * Service for sending network requests.
+	 * Legacy Transform.
 	 */
 
-	var xhr = __webpack_require__(4);
-	var jsonp = __webpack_require__(6);
-	var Promise = __webpack_require__(5);
+	var _ = __webpack_require__(1);
 
-	module.exports = function (_) {
+	module.exports = function (options, next) {
 
-	    var originUrl = _.url.parse(location.href);
-	    var jsonType = {'Content-Type': 'application/json;charset=utf-8'};
+	    var variables = [], url = next(options);
 
-	    function Http(url, options) {
+	    url = url.replace(/(\/?):([a-z]\w*)/gi, function (match, slash, name) {
 
-	        var promise;
+	        _.warn('The `:' + name + '` parameter syntax has been deprecated. Use the `{' + name + '}` syntax instead.');
 
-	        if (_.isPlainObject(url)) {
-	            options = url;
-	            url = '';
+	        if (options.params[name]) {
+	            variables.push(name);
+	            return slash + encodeUriSegment(options.params[name]);
 	        }
 
-	        options = _.extend({url: url}, options);
-	        options = _.extend(true, {},
-	            Http.options, this.options, options
-	        );
+	        return '';
+	    });
 
-	        if (options.crossOrigin === null) {
-	            options.crossOrigin = crossOrigin(options.url);
-	        }
+	    variables.forEach(function (key) {
+	        delete options.params[key];
+	    });
 
-	        options.method = options.method.toUpperCase();
-	        options.headers = _.extend({}, Http.headers.common,
-	            !options.crossOrigin ? Http.headers.custom : {},
-	            Http.headers[options.method.toLowerCase()],
-	            options.headers
-	        );
+	    return url;
+	};
 
-	        if (_.isPlainObject(options.data) && /^(GET|JSONP)$/i.test(options.method)) {
-	            _.extend(options.params, options.data);
-	            delete options.data;
-	        }
+	function encodeUriSegment(value) {
 
-	        if (options.emulateHTTP && !options.crossOrigin && /^(PUT|PATCH|DELETE)$/i.test(options.method)) {
-	            options.headers['X-HTTP-Method-Override'] = options.method;
-	            options.method = 'POST';
-	        }
+	    return encodeUriQuery(value, true).
+	        replace(/%26/gi, '&').
+	        replace(/%3D/gi, '=').
+	        replace(/%2B/gi, '+');
+	}
 
-	        if (options.emulateJSON && _.isPlainObject(options.data)) {
-	            options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
-	            options.data = _.url.params(options.data);
-	        }
+	function encodeUriQuery(value, spaces) {
 
-	        if (_.isObject(options.data) && /FormData/i.test(options.data.toString())) {
-	            delete options.headers['Content-Type'];
-	        }
+	    return encodeURIComponent(value).
+	        replace(/%40/gi, '@').
+	        replace(/%3A/gi, ':').
+	        replace(/%24/g, '$').
+	        replace(/%2C/gi, ',').
+	        replace(/%20/g, (spaces ? '%20' : '+'));
+	}
 
-	        if (_.isPlainObject(options.data)) {
-	            options.data = JSON.stringify(options.data);
-	        }
 
-	        promise = (options.method == 'JSONP' ? jsonp : xhr).call(this.vm, _, options);
-	        promise = extendPromise(promise.then(transformResponse, transformResponse), this.vm);
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
 
-	        if (options.success) {
-	            promise = promise.success(options.success);
-	        }
+	/**
+	 * Query Parameter Transform.
+	 */
 
-	        if (options.error) {
-	            promise = promise.error(options.error);
+	var _ = __webpack_require__(1);
+
+	module.exports = function (options, next) {
+
+	    var urlParams = Object.keys(_.url.options.params), query = {}, url = next(options);
+
+	   _.each(options.params, function (value, key) {
+	        if (urlParams.indexOf(key) === -1) {
+	            query[key] = value;
 	        }
+	    });
 
-	        return promise;
+	    query = _.url.params(query);
+
+	    if (query) {
+	        url += (url.indexOf('?') == -1 ? '?' : '&') + query;
 	    }
 
-	    function extendPromise(promise, vm) {
+	    return url;
+	};
+
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
 
-	        promise.success = function (fn) {
+	/**
+	 * Root Prefix Transform.
+	 */
 
-	            return extendPromise(promise.then(function (response) {
-	                return fn.call(vm, response.data, response.status, response) || response;
-	            }), vm);
+	var _ = __webpack_require__(1);
 
-	        };
+	module.exports = function (options, next) {
 
-	        promise.error = function (fn) {
+	    var url = next(options);
 
-	            return extendPromise(promise.then(undefined, function (response) {
-	                return fn.call(vm, response.data, response.status, response) || response;
-	            }), vm);
+	    if (_.isString(options.root) && !url.match(/^(https?:)?\//)) {
+	        url = options.root + '/' + url;
+	    }
 
-	        };
+	    return url;
+	};
 
-	        promise.always = function (fn) {
 
-	            var cb = function (response) {
-	                return fn.call(vm, response.data, response.status, response) || response;
-	            };
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
 
-	            return extendPromise(promise.then(cb, cb), vm);
-	        };
+	/**
+	 * Service for sending network requests.
+	 */
 
-	        return promise;
-	    }
+	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'};
 
-	    function transformResponse(response) {
+	function Http(url, options) {
 
-	        try {
-	            response.data = JSON.parse(response.responseText);
-	        } catch (e) {
-	            response.data = response.responseText;
-	        }
+	    var client = Client, request, promise;
+
+	    Http.interceptors.forEach(function (handler) {
+	        client = interceptor(handler, this.$vm)(client);
+	    }, this);
+
+	    options = _.isObject(url) ? url : _.extend({url: url}, options);
+	    request = _.merge({}, Http.options, this.$options, options);
+	    promise = client(request).bind(this.$vm).then(function (response) {
 
 	        return response.ok ? response : Promise.reject(response);
-	    }
 
-	    function crossOrigin(url) {
+	    }, function (response) {
+
+	        if (response instanceof Error) {
+	            _.error(response);
+	        }
 
-	        var requestUrl = _.url.parse(url);
+	        return Promise.reject(response);
+	    });
 
-	        return (requestUrl.protocol !== originUrl.protocol || requestUrl.host !== originUrl.host);
+	    if (request.success) {
+	        promise.success(request.success);
 	    }
 
-	    Http.options = {
-	        method: 'get',
-	        params: {},
-	        data: '',
-	        xhr: null,
-	        jsonp: 'callback',
-	        beforeSend: null,
-	        crossOrigin: null,
-	        emulateHTTP: false,
-	        emulateJSON: false
-	    };
+	    if (request.error) {
+	        promise.error(request.error);
+	    }
+
+	    return promise;
+	}
+
+	Http.options = {
+	    method: 'get',
+	    data: '',
+	    params: {},
+	    headers: {},
+	    xhr: null,
+	    upload: null,
+	    jsonp: 'callback',
+	    beforeSend: null,
+	    crossOrigin: null,
+	    emulateHTTP: false,
+	    emulateJSON: false,
+	    timeout: 0
+	};
+
+	Http.interceptors = [
+	    __webpack_require__(14),
+	    __webpack_require__(15),
+	    __webpack_require__(16),
+	    __webpack_require__(18),
+	    __webpack_require__(19),
+	    __webpack_require__(20),
+	    __webpack_require__(21)
+	];
+
+	Http.headers = {
+	    put: jsonType,
+	    post: jsonType,
+	    patch: jsonType,
+	    delete: jsonType,
+	    common: {'Accept': 'application/json, text/plain, */*'},
+	    custom: {'X-Requested-With': 'XMLHttpRequest'}
+	};
+
+	['get', 'put', 'post', 'patch', 'delete', 'jsonp'].forEach(function (method) {
+
+	    Http[method] = function (url, data, success, options) {
+
+	        if (_.isFunction(data)) {
+	            options = success;
+	            success = data;
+	            data = undefined;
+	        }
+
+	        if (_.isObject(success)) {
+	            options = success;
+	            success = undefined;
+	        }
 
-	    Http.headers = {
-	        put: jsonType,
-	        post: jsonType,
-	        patch: jsonType,
-	        delete: jsonType,
-	        common: {'Accept': 'application/json, text/plain, */*'},
-	        custom: {'X-Requested-With': 'XMLHttpRequest'}
+	        return this(url, _.extend({method: method, data: data, success: success}, options));
 	    };
+	});
 
-	    ['get', 'put', 'post', 'patch', 'delete', 'jsonp'].forEach(function (method) {
+	module.exports = _.http = Http;
 
-	        Http[method] = function (url, data, success, options) {
 
-	            if (_.isFunction(data)) {
-	                options = success;
-	                success = data;
-	                data = undefined;
-	            }
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
 
-	            return this(url, _.extend({method: method, data: data, success: success}, options));
-	        };
+	/**
+	 * Base client.
+	 */
+
+	var _ = __webpack_require__(1);
+	var Promise = __webpack_require__(10);
+	var xhrClient = __webpack_require__(12);
+
+	module.exports = function (request) {
+
+	    var response = (request.client || xhrClient)(request);
+
+	    return Promise.resolve(response).then(function (response) {
+
+	        if (response.headers) {
+
+	            var headers = parseHeaders(response.headers);
+
+	            response.headers = function (name) {
+
+	                if (name) {
+	                    return headers[_.toLower(name)];
+	                }
+
+	                return headers;
+	            };
+
+	        }
+
+	        response.ok = response.status >= 200 && response.status < 300;
+
+	        return response;
 	    });
 
-	    return _.http = Http;
 	};
 
+	function parseHeaders(str) {
+
+	    var headers = {}, value, name, i;
+
+	    if (_.isString(str)) {
+	        _.each(str.split('\n'), function (row) {
+
+	            i = row.indexOf(':');
+	            name = _.trim(_.toLower(row.slice(0, i)));
+	            value = _.trim(row.slice(i + 1));
+
+	            if (headers[name]) {
+
+	                if (_.isArray(headers[name])) {
+	                    headers[name].push(value);
+	                } else {
+	                    headers[name] = [headers[name], value];
+	                }
+
+	            } else {
+
+	                headers[name] = value;
+	            }
+
+	        });
+	    }
+
+	    return headers;
+	}
+
 
 /***/ },
-/* 4 */
+/* 10 */
 /***/ function(module, exports, __webpack_require__) {
 
 	/**
-	 * XMLHttp request.
+	 * Promise adapter.
 	 */
 
-	var Promise = __webpack_require__(5);
-	var XDomain = window.XDomainRequest;
+	var _ = __webpack_require__(1);
+	var PromiseObj = window.Promise || __webpack_require__(11);
+
+	function Promise(executor, context) {
+
+	    if (executor instanceof PromiseObj) {
+	        this.promise = executor;
+	    } else {
+	        this.promise = new PromiseObj(executor.bind(context));
+	    }
+
+	    this.context = context;
+	}
+
+	Promise.all = function (iterable, context) {
+	    return new Promise(PromiseObj.all(iterable), context);
+	};
+
+	Promise.resolve = function (value, context) {
+	    return new Promise(PromiseObj.resolve(value), context);
+	};
+
+	Promise.reject = function (reason, context) {
+	    return new Promise(PromiseObj.reject(reason), context);
+	};
+
+	Promise.race = function (iterable, context) {
+	    return new Promise(PromiseObj.race(iterable), context);
+	};
 
-	module.exports = function (_, options) {
+	var p = Promise.prototype;
 
-	    var request = new XMLHttpRequest(), promise;
+	p.bind = function (context) {
+	    this.context = context;
+	    return this;
+	};
 
-	    if (XDomain && options.crossOrigin) {
-	        request = new XDomainRequest(); options.headers = {};
+	p.then = function (fulfilled, rejected) {
+
+	    if (fulfilled && fulfilled.bind && this.context) {
+	        fulfilled = fulfilled.bind(this.context);
 	    }
 
-	    if (_.isPlainObject(options.xhr)) {
-	        _.extend(request, options.xhr);
+	    if (rejected && rejected.bind && this.context) {
+	        rejected = rejected.bind(this.context);
 	    }
 
-	    if (_.isFunction(options.beforeSend)) {
-	        options.beforeSend.call(this, request, options);
+	    this.promise = this.promise.then(fulfilled, rejected);
+
+	    return this;
+	};
+
+	p.catch = function (rejected) {
+
+	    if (rejected && rejected.bind && this.context) {
+	        rejected = rejected.bind(this.context);
 	    }
 
-	    promise = new Promise(function (resolve, reject) {
+	    this.promise = this.promise.catch(rejected);
 
-	        request.open(options.method, _.url(options), true);
+	    return this;
+	};
 
-	        _.each(options.headers, function (value, header) {
-	            request.setRequestHeader(header, value);
-	        });
+	p.finally = function (callback) {
 
-	        var handler = function (event) {
+	    return this.then(function (value) {
+	            callback.call(this);
+	            return value;
+	        }, function (reason) {
+	            callback.call(this);
+	            return PromiseObj.reject(reason);
+	        }
+	    );
+	};
 
-	            request.ok = event.type === 'load';
+	p.success = function (callback) {
 
-	            if (request.ok && request.status) {
-	                request.ok = request.status >= 200 && request.status < 300;
-	            }
+	    _.warn('The `success` method has been deprecated. Use the `then` method instead.');
 
-	            (request.ok ? resolve : reject)(request);
-	        };
+	    return this.then(function (response) {
+	        return callback.call(this, response.data, response.status, response) || response;
+	    });
+	};
+
+	p.error = function (callback) {
 
-	        request.onload = handler;
-	        request.onabort = handler;
-	        request.onerror = handler;
+	    _.warn('The `error` method has been deprecated. Use the `catch` method instead.');
 
-	        request.send(options.data);
+	    return this.catch(function (response) {
+	        return callback.call(this, response.data, response.status, response) || response;
 	    });
+	};
 
-	    return promise;
+	p.always = function (callback) {
+
+	    _.warn('The `always` method has been deprecated. Use the `finally` method instead.');
+
+	    var cb = function (response) {
+	        return callback.call(this, response.data, response.status, response) || response;
+	    };
+
+	    return this.then(cb, cb);
 	};
 
+	module.exports = Promise;
+
 
 /***/ },
-/* 5 */
-/***/ function(module, exports) {
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
 
 	/**
-	 * Promises/A+ polyfill v1.1.0 (https://github.com/bramstein/promis)
+	 * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)
 	 */
 
+	var _ = __webpack_require__(1);
+
 	var RESOLVED = 0;
 	var REJECTED = 1;
 	var PENDING  = 2;
@@ -618,8 +998,7 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	Promise.all = function all(iterable) {
 	    return new Promise(function (resolve, reject) {
-	        var count = 0,
-	            result = [];
+	        var count = 0, result = [];
 
 	        if (iterable.length === 0) {
 	            resolve(result);
@@ -637,7 +1016,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	        }
 
 	        for (var i = 0; i < iterable.length; i += 1) {
-	            iterable[i].then(resolver(i), reject);
+	            Promise.resolve(iterable[i]).then(resolver(i), reject);
 	        }
 	    });
 	};
@@ -645,7 +1024,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	Promise.race = function race(iterable) {
 	    return new Promise(function (resolve, reject) {
 	        for (var i = 0; i < iterable.length; i += 1) {
-	            iterable[i].then(resolve, reject);
+	            Promise.resolve(iterable[i]).then(resolve, reject);
 	        }
 	    });
 	};
@@ -686,6 +1065,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	            }
 	            return;
 	        }
+
 	        promise.state = RESOLVED;
 	        promise.value = x;
 	        promise.notify();
@@ -709,7 +1089,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	p.notify = function notify() {
 	    var promise = this;
 
-	    async(function () {
+	    _.nextTick(function () {
 	        if (promise.state !== PENDING) {
 	            while (promise.deferred.length) {
 	                var deferred = promise.deferred.shift(),
@@ -740,10 +1120,6 @@ return /******/ (function(modules) { // webpackBootstrap
 	    });
 	};
 
-	p.catch = function (onRejected) {
-	    return this.then(undefined, onRejected);
-	};
-
 	p.then = function then(onResolved, onRejected) {
 	    var promise = this;
 
@@ -753,87 +1129,248 @@ return /******/ (function(modules) { // webpackBootstrap
 	    });
 	};
 
-	var queue = [];
-	var async = function (callback) {
-	    queue.push(callback);
-
-	    if (queue.length === 1) {
-	        async.async();
-	    }
+	p.catch = function (onRejected) {
+	    return this.then(undefined, onRejected);
 	};
 
-	async.run = function () {
-	    while (queue.length) {
-	        queue[0]();
-	        queue.shift();
-	    }
-	};
+	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 (event) {
+
+	            response.data = xhr.responseText;
+	            response.status = xhr.status;
+	            response.statusText = xhr.statusText;
+	            response.headers = xhr.getAllResponseHeaders();
+
+	            resolve(response);
+	        };
 
-	if (window.MutationObserver) {
-	    var el = document.createElement('div');
-	    var mo = new MutationObserver(async.run);
+	        xhr.timeout = 0;
+	        xhr.onload = handler;
+	        xhr.onabort = handler;
+	        xhr.onerror = handler;
+	        xhr.ontimeout = function () {};
+	        xhr.onprogress = function () {};
 
-	    mo.observe(el, {
-	        attributes: true
+	        if (_.isPlainObject(request.xhr)) {
+	            _.extend(xhr, request.xhr);
+	        }
+
+	        if (_.isPlainObject(request.upload)) {
+	            _.extend(xhr.upload, request.upload);
+	        }
+
+	        _.each(request.headers || {}, function (value, header) {
+	            xhr.setRequestHeader(header, value);
+	        });
+
+	        xhr.send(request.data);
 	    });
+	};
 
-	    async.async = function () {
-	        el.setAttribute("x", 0);
-	    };
-	} else {
-	    async.async = function () {
-	        setTimeout(async.run);
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Interceptor factory.
+	 */
+
+	var _ = __webpack_require__(1);
+	var Promise = __webpack_require__(10);
+
+	module.exports = function (handler, vm) {
+
+	    return function (client) {
+
+	        if (_.isFunction(handler)) {
+	            handler = handler.call(vm, Promise);
+	        }
+
+	        return function (request) {
+
+	            if (_.isFunction(handler.request)) {
+	                request = handler.request.call(vm, request);
+	            }
+
+	            return when(request, function (request) {
+	                return when(client(request), function (response) {
+
+	                    if (_.isFunction(handler.response)) {
+	                        response = handler.response.call(vm, response);
+	                    }
+
+	                    return response;
+	                });
+	            });
+	        };
 	    };
+	};
+
+	function when(value, fulfilled, rejected) {
+
+	    var promise = Promise.resolve(value);
+
+	    if (arguments.length < 2) {
+	        return promise;
+	    }
+
+	    return promise.then(fulfilled, rejected);
 	}
 
-	module.exports = window.Promise || Promise;
+
+/***/ },
+/* 14 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Before Interceptor.
+	 */
+
+	var _ = __webpack_require__(1);
+
+	module.exports = {
+
+	    request: function (request) {
+
+	        if (_.isFunction(request.beforeSend)) {
+	            request.beforeSend.call(this, request);
+	        }
+
+	        return request;
+	    }
+
+	};
 
 
 /***/ },
-/* 6 */
+/* 15 */
+/***/ function(module, exports) {
+
+	/**
+	 * Timeout Interceptor.
+	 */
+
+	module.exports = function () {
+
+	    var timeout;
+
+	    return {
+
+	        request: function (request) {
+
+	            if (request.timeout) {
+	                timeout = setTimeout(function () {
+	                    request.cancel();
+	                }, request.timeout);
+	            }
+
+	            return request;
+	        },
+
+	        response: function (response) {
+
+	            clearTimeout(timeout);
+
+	            return response;
+	        }
+
+	    };
+	};
+
+
+/***/ },
+/* 16 */
 /***/ function(module, exports, __webpack_require__) {
 
 	/**
-	 * JSONP request.
+	 * JSONP Interceptor.
 	 */
 
-	var Promise = __webpack_require__(5);
+	var jsonpClient = __webpack_require__(17);
 
-	module.exports = function (_, options) {
+	module.exports = {
 
-	    var callback = '_jsonp' + Math.random().toString(36).substr(2), response = {}, script, body;
+	    request: function (request) {
 
-	    options.params[options.jsonp] = callback;
+	        if (request.method == 'JSONP') {
+	            request.client = jsonpClient;
+	        }
 
-	    if (_.isFunction(options.beforeSend)) {
-	        options.beforeSend.call(this, {}, options);
+	        return request;
 	    }
 
-	    return new Promise(function (resolve, reject) {
+	};
+
+
+/***/ },
+/* 17 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * JSONP client.
+	 */
+
+	var _ = __webpack_require__(1);
+	var Promise = __webpack_require__(10);
+
+	module.exports = function (request) {
+	    return new Promise(function (resolve) {
+
+	        var callback = '_jsonp' + Math.random().toString(36).substr(2), response = {request: request, data: null}, handler, script;
+
+	        request.params[request.jsonp] = callback;
+	        request.cancel = function () {
+	            handler({type: 'cancel'});
+	        };
 
 	        script = document.createElement('script');
-	        script.src = _.url(options);
+	        script.src = _.url(request);
 	        script.type = 'text/javascript';
 	        script.async = true;
 
 	        window[callback] = function (data) {
-	            body = data;
+	            response.data = data;
 	        };
 
-	        var handler = function (event) {
+	        handler = function (event) {
 
-	            delete window[callback];
-	            document.body.removeChild(script);
-
-	            if (event.type === 'load' && !body) {
-	                event.type = 'error';
+	            if (event.type === 'load' && response.data !== null) {
+	                response.status = 200;
+	            } else if (event.type === 'error') {
+	                response.status = 404;
+	            } else {
+	                response.status = 0;
 	            }
 
-	            response.ok = event.type !== 'error';
-	            response.status = response.ok ? 200 : 404;
-	            response.responseText = body ? body : event.type;
+	            resolve(response);
 
-	            (response.ok ? resolve : reject)(response);
+	            delete window[callback];
+	            document.body.removeChild(script);
 	        };
 
 	        script.onload = handler;
@@ -841,128 +1378,309 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	        document.body.appendChild(script);
 	    });
-
 	};
 
 
 /***/ },
-/* 7 */
+/* 18 */
 /***/ function(module, exports) {
 
 	/**
-	 * Service for interacting with RESTful services.
+	 * HTTP method override Interceptor.
+	 */
+
+	module.exports = {
+
+	    request: function (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) {
+
+	        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) {
+
+	        try {
+	            response.data = JSON.parse(response.data);
+	        } catch (e) {}
+
+	        return response;
+	    }
+
+	};
+
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Header Interceptor.
 	 */
 
-	module.exports = function (_) {
+	var _ = __webpack_require__(1);
 
-	    function Resource(url, params, actions) {
+	module.exports = {
 
-	        var self = this, resource = {};
+	    request: function (request) {
 
-	        actions = _.extend({},
-	            Resource.actions,
-	            actions
+	        request.method = request.method.toUpperCase();
+	        request.headers = _.extend({}, _.http.headers.common,
+	            !request.crossOrigin ? _.http.headers.custom : {},
+	            _.http.headers[request.method.toLowerCase()],
+	            request.headers
 	        );
 
-	        _.each(actions, function (action, name) {
+	        if (_.isPlainObject(request.data) && /^(GET|JSONP)$/i.test(request.method)) {
+	            _.extend(request.params, request.data);
+	            delete request.data;
+	        }
 
-	            action = _.extend(true, {url: url, params: params || {}}, action);
+	        return request;
+	    }
 
-	            resource[name] = function () {
-	                return (self.$http || _.http)(opts(action, arguments));
-	            };
-	        });
+	};
+
+
+/***/ },
+/* 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) {
+
+	        if (request.crossOrigin === null) {
+	            request.crossOrigin = crossOrigin(request);
+	        }
+
+	        if (request.crossOrigin) {
+
+	            if (!xhrCors) {
+	                request.client = xdrClient;
+	            }
 
-	        return resource;
+	            request.emulateHTTP = false;
+	        }
+
+	        return request;
 	    }
 
-	    function opts(action, args) {
+	};
+
+	function crossOrigin(request) {
 
-	        var options = _.extend({}, action), params = {}, data, success, error;
+	    var requestUrl = _.url.parse(_.url(request));
 
-	        switch (args.length) {
+	    return (requestUrl.protocol !== originUrl.protocol || requestUrl.host !== originUrl.host);
+	}
 
-	            case 4:
 
-	                error = args[3];
-	                success = args[2];
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
 
-	            case 3:
-	            case 2:
+	/**
+	 * XDomain client (Internet Explorer).
+	 */
 
-	                if (_.isFunction(args[1])) {
+	var _ = __webpack_require__(1);
+	var Promise = __webpack_require__(10);
 
-	                    if (_.isFunction(args[0])) {
+	module.exports = function (request) {
+	    return new Promise(function (resolve) {
 
-	                        success = args[0];
-	                        error = args[1];
+	        var xdr = new XDomainRequest(), response = {request: request}, handler;
 
-	                        break;
-	                    }
+	        request.cancel = function () {
+	            xdr.abort();
+	        };
 
-	                    success = args[1];
-	                    error = args[2];
+	        xdr.open(request.method, _.url(request), true);
 
-	                } else {
+	        handler = function (event) {
 
-	                    params = args[0];
-	                    data = args[1];
-	                    success = args[2];
+	            response.data = xdr.responseText;
+	            response.status = xdr.status;
+	            response.statusText = xdr.statusText;
 
-	                    break;
-	                }
+	            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 1:
+	        case 3:
+	        case 2:
+
+	            if (_.isFunction(args[1])) {
 
 	                if (_.isFunction(args[0])) {
+
 	                    success = args[0];
-	                } else if (/^(POST|PUT|PATCH)$/i.test(options.method)) {
-	                    data = args[0];
-	                } else {
-	                    params = args[0];
+	                    error = args[1];
+
+	                    break;
 	                }
 
-	                break;
+	                success = args[1];
+	                error = args[2];
+
+	            } else {
 
-	            case 0:
+	                params = args[0];
+	                data = args[1];
+	                success = args[2];
 
 	                break;
+	            }
 
-	            default:
+	        case 1:
 
-	                throw 'Expected up to 4 arguments [params, data, success, error], got ' + args.length + ' arguments';
-	        }
+	            if (_.isFunction(args[0])) {
+	                success = args[0];
+	            } else if (/^(POST|PUT|PATCH)$/i.test(options.method)) {
+	                data = args[0];
+	            } else {
+	                params = args[0];
+	            }
 
-	        options.data = data;
-	        options.params = _.extend({}, options.params, params);
+	            break;
 
-	        if (success) {
-	            options.success = success;
-	        }
+	        case 0:
 
-	        if (error) {
-	            options.error = error;
-	        }
+	            break;
+
+	        default:
 
-	        return options;
+	            throw 'Expected up to 4 arguments [params, data, success, error], got ' + args.length + ' arguments';
 	    }
 
-	    Resource.actions = {
+	    options.data = data;
+	    options.params = _.extend({}, options.params, params);
 
-	        get: {method: 'GET'},
-	        save: {method: 'POST'},
-	        query: {method: 'GET'},
-	        update: {method: 'PUT'},
-	        remove: {method: 'DELETE'},
-	        delete: {method: 'DELETE'}
+	    if (success) {
+	        options.success = success;
+	    }
 
-	    };
+	    if (error) {
+	        options.error = error;
+	    }
+
+	    return options;
+	}
+
+	Resource.actions = {
+
+	    get: {method: 'GET'},
+	    save: {method: 'POST'},
+	    query: {method: 'GET'},
+	    update: {method: 'PUT'},
+	    remove: {method: 'DELETE'},
+	    delete: {method: 'DELETE'}
 
-	    return _.resource = Resource;
 	};
 
+	module.exports = _.resource = Resource;
+
 
 /***/ }
 /******/ ])
 });
-;
+;