made with requirebin
Last active
April 18, 2016 22:11
-
-
Save impronunciable/3204b4f40256060ab41d6cd432a10684 to your computer and use it in GitHub Desktop.
requirebin sketch
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| var XeniaDriver = require('xenia-driver') | |
| // Configure your instance | |
| var xenia = XeniaDriver('https://demo.coralproject.net/xenia_api/1.0', 'Basic NmQ3MmU2ZGQtOTNkMC00NDEzLTliNGMtODU0NmQ0ZDM1MTRlOlBDeVgvTFRHWjhOdGZWOGVReXZObkpydm4xc2loQk9uQW5TNFpGZGNFdnc9') | |
| // Use the driver | |
| xenia() | |
| .collection('comments') | |
| .include(['body', 'asset_id']) | |
| .limit(5) | |
| .join('assets', '_id', 'asset_id', 'asset') | |
| .include(['section']) | |
| .exec().then(data => document.write(JSON.stringify(data.results, null, '\t'))) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| setTimeout(function(){ | |
| ;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"xenia-driver":[function(require,module,exports){ | |
| module.exports = | |
| /******/ (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__) { | |
| 'use strict'; | |
| 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; }; | |
| var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); | |
| /** | |
| * Module dependencies | |
| */ | |
| var _axios = __webpack_require__(1); | |
| var _axios2 = _interopRequireDefault(_axios); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } | |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
| /** | |
| * Module constants | |
| */ | |
| var dataSchema = { | |
| name: 'my_query', | |
| desc: 'made with xenia driver', | |
| enabled: true | |
| }; | |
| var querySchema = { | |
| name: 'my_query', | |
| type: 'pipeline', | |
| collection: 'user_statistics', | |
| return: true | |
| }; | |
| /** | |
| * Driver Class | |
| * @class | |
| */ | |
| var XeniaDriver = function () { | |
| /** | |
| * Initialize the driver | |
| * @constructor | |
| * @param {string} base url - Xenia base url | |
| * @param {object | string} Auth - Xenia basic authentication credentials | |
| * @param {object} parameters - extra parameters; optional | |
| * @param {object} request parameters - overrides extra parameters; optional | |
| */ | |
| function XeniaDriver(baseURL, auth) { | |
| var params = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; | |
| var reqParams = arguments[3]; | |
| _classCallCheck(this, XeniaDriver); | |
| if ('string' !== typeof baseURL) { | |
| throw new Error('A base url is needed for the Xenia Driver to work.'); | |
| } | |
| if ('object' !== (typeof auth === 'undefined' ? 'undefined' : _typeof(auth)) && 'string' !== typeof auth) { | |
| throw new Error('An authorization object ({username, password}) or a Basic Authentication string is needed for the Xenia Driver to work.'); | |
| } | |
| this._baseURL = baseURL; | |
| this._auth = auth; | |
| this._params = params; | |
| var headers = {}; | |
| if (typeof auth === 'string') { | |
| headers.Authorization = auth; | |
| auth = null; | |
| } | |
| // Initialize the request instance | |
| this._request = _axios2.default.create({ | |
| baseURL: baseURL, | |
| auth: auth, | |
| headers: headers, | |
| timeout: 10000 | |
| }); | |
| // Initialize the query | |
| this._data = Object.assign({}, dataSchema, { params: [], queries: [] }, params.defaults, reqParams); | |
| if (!reqParams) { | |
| this.addQuery(params); | |
| } | |
| return this; | |
| } | |
| /** | |
| * Commit the current query | |
| * @private | |
| */ | |
| _createClass(XeniaDriver, [{ | |
| key: '_commitQuery', | |
| value: function _commitQuery() { | |
| if (this._query) { | |
| this._query.commands = this._commands; | |
| this._query._pendingJoin = this._pendingJoin; | |
| this._data.queries.push(this._query); | |
| } | |
| this._query = null; | |
| this._pendingJoin = null; | |
| return this; | |
| } | |
| /** | |
| * Initialize a query | |
| * @param {object} query object - optional | |
| */ | |
| }, { | |
| key: 'addQuery', | |
| value: function addQuery() { | |
| var queryData = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; | |
| var rand = Math.floor(Math.random() * 9999); | |
| this._commitQuery(); | |
| this._query = Object.assign({}, querySchema, queryData, { name: 'my_query_' + rand, commands: [] }); | |
| this._commands = []; | |
| return this; | |
| } | |
| /** | |
| * Set the collection for the current query | |
| * @param {string} collection name | |
| */ | |
| }, { | |
| key: 'collection', | |
| value: function collection() { | |
| var name = arguments.length <= 0 || arguments[0] === undefined ? 'user_statistics' : arguments[0]; | |
| this._query.collection = name; | |
| return this; | |
| } | |
| /** | |
| * Executes the request | |
| * @api private | |
| * @param {string} query name - optional | |
| * @param {object} query parameters - optional | |
| */ | |
| }, { | |
| key: '_execRequest', | |
| value: function _execRequest() { | |
| var method = arguments.length <= 0 || arguments[0] === undefined ? 'post' : arguments[0]; | |
| var _this = this; | |
| var path = arguments.length <= 1 || arguments[1] === undefined ? '/exec' : arguments[1]; | |
| var data = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; | |
| return this._request[method](path, data).then(function (res) { | |
| return res.data; | |
| }) | |
| // perform join match | |
| .then(function (data) { | |
| if (!data.results) return data; | |
| data.results.forEach(function (res, i) { | |
| if (!_this._data.queries[i]) return; | |
| var pendingJoin = _this._data.queries[i]._pendingJoin; | |
| if (pendingJoin) { | |
| res.Docs = res.Docs.map(function (doc) { | |
| var match = data.results[i + 1].Docs.find(function (nextDoc) { | |
| return nextDoc[pendingJoin.field] === doc[pendingJoin.matchingField]; | |
| }); | |
| doc[pendingJoin.name] = match; | |
| return doc; | |
| }); | |
| } | |
| }); | |
| return data; | |
| }); | |
| } | |
| /** | |
| * Executes the request | |
| * @param {string} query name - optional | |
| * @param {object} query parameters - optional | |
| */ | |
| }, { | |
| key: 'exec', | |
| value: function exec(queryName) { | |
| var params = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; | |
| if ('string' !== typeof queryName) { | |
| this._commitQuery(); | |
| return this._execRequest('post', '/exec', this._data); | |
| } else { | |
| return this._execRequest('get', '/exec/' + queryName, { params: params }); | |
| } | |
| } | |
| /** | |
| * Get a list of available queries | |
| */ | |
| }, { | |
| key: 'getQueries', | |
| value: function getQueries() { | |
| return this._execRequest('get', '/query'); | |
| } | |
| /** | |
| * Get a specific queryset document | |
| * @param {string} query name | |
| */ | |
| }, { | |
| key: 'getQuery', | |
| value: function getQuery(name) { | |
| return this._execRequest('get', '/query/' + name); | |
| } | |
| /** | |
| * Save a query into xenia instead of executing it | |
| */ | |
| }, { | |
| key: 'saveQuery', | |
| value: function saveQuery(name) { | |
| if (name) { | |
| this._data.name = name; | |
| } | |
| return this._request.put('/query', this._data).then(function (res) { | |
| return res.data; | |
| }); | |
| } | |
| /** | |
| * Delete a query from xenia | |
| * @param {String} name | |
| */ | |
| }, { | |
| key: 'deleteQuery', | |
| value: function deleteQuery(name) { | |
| if (name) { | |
| this._data.name = name; | |
| } | |
| return this._request.delete('/query/' + name).then(function (res) { | |
| return res.data; | |
| }); | |
| } | |
| /** | |
| * Limit the amount of retrieved documents | |
| * @param {number} limit - default: 20 | |
| */ | |
| }, { | |
| key: 'limit', | |
| value: function limit() { | |
| var n = arguments.length <= 0 || arguments[0] === undefined ? 20 : arguments[0]; | |
| this._commands.push({ '$limit': n }); | |
| return this; | |
| } | |
| /** | |
| * Skip the first n documents | |
| * @param {number} skip - default: 0 | |
| */ | |
| }, { | |
| key: 'skip', | |
| value: function skip() { | |
| var n = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; | |
| this._commands.push({ '$skip': n }); | |
| return this; | |
| } | |
| /** | |
| * Return a document sample from the collection | |
| * @param {number} size - default: 20 | |
| */ | |
| }, { | |
| key: 'sample', | |
| value: function sample() { | |
| var size = arguments.length <= 0 || arguments[0] === undefined ? 20 : arguments[0]; | |
| this._commands.push({ '$sample': { size: size } }); | |
| return this; | |
| } | |
| /** | |
| * Include and exclude fields from the result | |
| * @param {object} fields | |
| */ | |
| }, { | |
| key: 'project', | |
| value: function project() { | |
| var fields = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; | |
| this._commands.push({ '$project': fields }); | |
| return this; | |
| } | |
| /** | |
| * Whitelist retrieved fields | |
| * @param {array} fields | |
| */ | |
| }, { | |
| key: 'include', | |
| value: function include() { | |
| var fields = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0]; | |
| var obj = {}; | |
| fields.forEach(function (field) { | |
| return obj[field] = true; | |
| }); | |
| this._commands.push({ '$project': obj }); | |
| return this; | |
| } | |
| /** | |
| * Blacklist retrieved fields | |
| * @param {array} fields | |
| */ | |
| }, { | |
| key: 'exclude', | |
| value: function exclude() { | |
| var fields = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0]; | |
| var obj = {}; | |
| fields.forEach(function (field) { | |
| return obj[field] = false; | |
| }); | |
| this._commands.push({ '$project': obj }); | |
| return this; | |
| } | |
| /** | |
| * Performs a match command | |
| * @param {object} match | |
| */ | |
| }, { | |
| key: 'match', | |
| value: function match() { | |
| var query = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; | |
| this._commands.push({ '$match': query }); | |
| return this; | |
| } | |
| /** | |
| * Performs a redact command | |
| * @param {object} match | |
| */ | |
| }, { | |
| key: 'redact', | |
| value: function redact() { | |
| var query = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; | |
| this._commands.push({ '$redact': query }); | |
| return this; | |
| } | |
| /** | |
| * Deconstructs an array field from the input documents to | |
| * output a document for each element | |
| * @param {string} path | |
| * @param {string} include array index - optional | |
| * @param {boolean} preserve null and empty arrays - optional | |
| */ | |
| }, { | |
| key: 'unwind', | |
| value: function unwind() { | |
| var path = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; | |
| var includeArrayIndex = arguments[1]; | |
| var preserveNullAndEmptyArrays = arguments[2]; | |
| this._commands.push({ '$unwind': { path: path, includeArrayIndex: includeArrayIndex, preserveNullAndEmptyArrays: preserveNullAndEmptyArrays } }); | |
| return this; | |
| } | |
| /** | |
| * Group documents | |
| * @param {object} group | |
| */ | |
| }, { | |
| key: 'group', | |
| value: function group() { | |
| var groups = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; | |
| this._commands.push({ '$group': groups }); | |
| return this; | |
| } | |
| /** | |
| * Sort documents | |
| * @param {object|array} sorting data | |
| */ | |
| }, { | |
| key: 'sort', | |
| value: function sort() { | |
| var order = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; | |
| if (Array.isArray(order)) { | |
| this._commands.push({ '$sort': _defineProperty({}, order[0], order[1]) }); | |
| } else { | |
| this._commands.push({ '$sort': order }); | |
| } | |
| return this; | |
| } | |
| /** | |
| * Creates a new query joining the actual one using the save method | |
| * from Xenia | |
| * @param {string} collection | |
| * @param {string} field - default: _id | |
| * @param {string} matching field - default: field | |
| * @param {sting} join parameter name - default: 'list' | |
| */ | |
| }, { | |
| key: 'join', | |
| value: function join(collection) { | |
| var field = arguments.length <= 1 || arguments[1] === undefined ? '_id' : arguments[1]; | |
| var matchingField = arguments[2]; | |
| var name = arguments.length <= 3 || arguments[3] === undefined ? 'list' : arguments[3]; | |
| if (!matchingField) { | |
| matchingField = field; | |
| } | |
| this._pendingJoin = { field: field, matchingField: matchingField, name: name }; | |
| this._commands.push({ '$save': { '$map': name } }); | |
| this.addQuery().collection(collection).match(_defineProperty({}, field, { '$in': '#data.*:' + name + '.' + matchingField })); | |
| return this; | |
| } | |
| }]); | |
| return XeniaDriver; | |
| }(); | |
| /** | |
| * Expose a function that just create a new XeniaDriver instance | |
| * so you don't need to use the `new` keyword ¯\_(ツ)_/¯ | |
| */ | |
| module.exports = function (url, auth, params) { | |
| return function (reqParams) { | |
| return new XeniaDriver(url, auth, params, reqParams); | |
| }; | |
| }; | |
| /***/ }, | |
| /* 1 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| module.exports = __webpack_require__(2); | |
| /***/ }, | |
| /* 2 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| 'use strict'; | |
| var defaults = __webpack_require__(3); | |
| var utils = __webpack_require__(4); | |
| var dispatchRequest = __webpack_require__(5); | |
| var InterceptorManager = __webpack_require__(14); | |
| var isAbsoluteURL = __webpack_require__(15); | |
| var combineURLs = __webpack_require__(16); | |
| var bind = __webpack_require__(17); | |
| var transformData = __webpack_require__(10); | |
| function Axios(defaultConfig) { | |
| this.defaults = utils.merge({}, defaultConfig); | |
| this.interceptors = { | |
| request: new InterceptorManager(), | |
| response: new InterceptorManager() | |
| }; | |
| } | |
| Axios.prototype.request = function request(config) { | |
| /*eslint no-param-reassign:0*/ | |
| // Allow for axios('example/url'[, config]) a la fetch API | |
| if (typeof config === 'string') { | |
| config = utils.merge({ | |
| url: arguments[0] | |
| }, arguments[1]); | |
| } | |
| config = utils.merge(defaults, this.defaults, { method: 'get' }, config); | |
| // Support baseURL config | |
| if (config.baseURL && !isAbsoluteURL(config.url)) { | |
| config.url = combineURLs(config.baseURL, config.url); | |
| } | |
| // Don't allow overriding defaults.withCredentials | |
| config.withCredentials = config.withCredentials || this.defaults.withCredentials; | |
| // Transform request data | |
| config.data = transformData( | |
| config.data, | |
| config.headers, | |
| config.transformRequest | |
| ); | |
| // Flatten headers | |
| config.headers = utils.merge( | |
| config.headers.common || {}, | |
| config.headers[config.method] || {}, | |
| config.headers || {} | |
| ); | |
| utils.forEach( | |
| ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], | |
| function cleanHeaderConfig(method) { | |
| delete config.headers[method]; | |
| } | |
| ); | |
| // Hook up interceptors middleware | |
| var chain = [dispatchRequest, undefined]; | |
| var promise = Promise.resolve(config); | |
| this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { | |
| chain.unshift(interceptor.fulfilled, interceptor.rejected); | |
| }); | |
| this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { | |
| chain.push(interceptor.fulfilled, interceptor.rejected); | |
| }); | |
| while (chain.length) { | |
| promise = promise.then(chain.shift(), chain.shift()); | |
| } | |
| return promise; | |
| }; | |
| var defaultInstance = new Axios(defaults); | |
| var axios = module.exports = bind(Axios.prototype.request, defaultInstance); | |
| axios.create = function create(defaultConfig) { | |
| return new Axios(defaultConfig); | |
| }; | |
| // Expose defaults | |
| axios.defaults = defaultInstance.defaults; | |
| // Expose all/spread | |
| axios.all = function all(promises) { | |
| return Promise.all(promises); | |
| }; | |
| axios.spread = __webpack_require__(18); | |
| // Expose interceptors | |
| axios.interceptors = defaultInstance.interceptors; | |
| // Provide aliases for supported request methods | |
| utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) { | |
| /*eslint func-names:0*/ | |
| Axios.prototype[method] = function(url, config) { | |
| return this.request(utils.merge(config || {}, { | |
| method: method, | |
| url: url | |
| })); | |
| }; | |
| axios[method] = bind(Axios.prototype[method], defaultInstance); | |
| }); | |
| utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { | |
| /*eslint func-names:0*/ | |
| Axios.prototype[method] = function(url, data, config) { | |
| return this.request(utils.merge(config || {}, { | |
| method: method, | |
| url: url, | |
| data: data | |
| })); | |
| }; | |
| axios[method] = bind(Axios.prototype[method], defaultInstance); | |
| }); | |
| /***/ }, | |
| /* 3 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| 'use strict'; | |
| var utils = __webpack_require__(4); | |
| var PROTECTION_PREFIX = /^\)\]\}',?\n/; | |
| var DEFAULT_CONTENT_TYPE = { | |
| 'Content-Type': 'application/x-www-form-urlencoded' | |
| }; | |
| module.exports = { | |
| transformRequest: [function transformResponseJSON(data, headers) { | |
| if (utils.isFormData(data)) { | |
| return data; | |
| } | |
| if (utils.isArrayBuffer(data)) { | |
| return data; | |
| } | |
| if (utils.isArrayBufferView(data)) { | |
| return data.buffer; | |
| } | |
| if (utils.isObject(data) && !utils.isFile(data) && !utils.isBlob(data)) { | |
| // Set application/json if no Content-Type has been specified | |
| if (!utils.isUndefined(headers)) { | |
| utils.forEach(headers, function processContentTypeHeader(val, key) { | |
| if (key.toLowerCase() === 'content-type') { | |
| headers['Content-Type'] = val; | |
| } | |
| }); | |
| if (utils.isUndefined(headers['Content-Type'])) { | |
| headers['Content-Type'] = 'application/json;charset=utf-8'; | |
| } | |
| } | |
| return JSON.stringify(data); | |
| } | |
| return data; | |
| }], | |
| transformResponse: [function transformResponseJSON(data) { | |
| /*eslint no-param-reassign:0*/ | |
| if (typeof data === 'string') { | |
| data = data.replace(PROTECTION_PREFIX, ''); | |
| try { | |
| data = JSON.parse(data); | |
| } catch (e) { /* Ignore */ } | |
| } | |
| return data; | |
| }], | |
| headers: { | |
| common: { | |
| 'Accept': 'application/json, text/plain, */*' | |
| }, | |
| patch: utils.merge(DEFAULT_CONTENT_TYPE), | |
| post: utils.merge(DEFAULT_CONTENT_TYPE), | |
| put: utils.merge(DEFAULT_CONTENT_TYPE) | |
| }, | |
| timeout: 0, | |
| xsrfCookieName: 'XSRF-TOKEN', | |
| xsrfHeaderName: 'X-XSRF-TOKEN' | |
| }; | |
| /***/ }, | |
| /* 4 */ | |
| /***/ function(module, exports) { | |
| 'use strict'; | |
| /*global toString:true*/ | |
| // utils is a library of generic helper functions non-specific to axios | |
| var toString = Object.prototype.toString; | |
| /** | |
| * Determine if a value is an Array | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is an Array, otherwise false | |
| */ | |
| function isArray(val) { | |
| return toString.call(val) === '[object Array]'; | |
| } | |
| /** | |
| * Determine if a value is an ArrayBuffer | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is an ArrayBuffer, otherwise false | |
| */ | |
| function isArrayBuffer(val) { | |
| return toString.call(val) === '[object ArrayBuffer]'; | |
| } | |
| /** | |
| * Determine if a value is a FormData | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is an FormData, otherwise false | |
| */ | |
| function isFormData(val) { | |
| return toString.call(val) === '[object FormData]'; | |
| } | |
| /** | |
| * Determine if a value is a view on an ArrayBuffer | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false | |
| */ | |
| function isArrayBufferView(val) { | |
| var result; | |
| if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) { | |
| result = ArrayBuffer.isView(val); | |
| } else { | |
| result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer); | |
| } | |
| return result; | |
| } | |
| /** | |
| * Determine if a value is a String | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is a String, otherwise false | |
| */ | |
| function isString(val) { | |
| return typeof val === 'string'; | |
| } | |
| /** | |
| * Determine if a value is a Number | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is a Number, otherwise false | |
| */ | |
| function isNumber(val) { | |
| return typeof val === 'number'; | |
| } | |
| /** | |
| * Determine if a value is undefined | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if the value is undefined, otherwise false | |
| */ | |
| function isUndefined(val) { | |
| return typeof val === 'undefined'; | |
| } | |
| /** | |
| * Determine if a value is an Object | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is an Object, otherwise false | |
| */ | |
| function isObject(val) { | |
| return val !== null && typeof val === 'object'; | |
| } | |
| /** | |
| * Determine if a value is a Date | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is a Date, otherwise false | |
| */ | |
| function isDate(val) { | |
| return toString.call(val) === '[object Date]'; | |
| } | |
| /** | |
| * Determine if a value is a File | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is a File, otherwise false | |
| */ | |
| function isFile(val) { | |
| return toString.call(val) === '[object File]'; | |
| } | |
| /** | |
| * Determine if a value is a Blob | |
| * | |
| * @param {Object} val The value to test | |
| * @returns {boolean} True if value is a Blob, otherwise false | |
| */ | |
| function isBlob(val) { | |
| return toString.call(val) === '[object Blob]'; | |
| } | |
| /** | |
| * Trim excess whitespace off the beginning and end of a string | |
| * | |
| * @param {String} str The String to trim | |
| * @returns {String} The String freed of excess whitespace | |
| */ | |
| function trim(str) { | |
| return str.replace(/^\s*/, '').replace(/\s*$/, ''); | |
| } | |
| /** | |
| * Determine if we're running in a standard browser environment | |
| * | |
| * This allows axios to run in a web worker, and react-native. | |
| * Both environments support XMLHttpRequest, but not fully standard globals. | |
| * | |
| * web workers: | |
| * typeof window -> undefined | |
| * typeof document -> undefined | |
| * | |
| * react-native: | |
| * typeof document.createElement -> undefined | |
| */ | |
| function isStandardBrowserEnv() { | |
| return ( | |
| typeof window !== 'undefined' && | |
| typeof document !== 'undefined' && | |
| typeof document.createElement === 'function' | |
| ); | |
| } | |
| /** | |
| * Iterate over an Array or an Object invoking a function for each item. | |
| * | |
| * If `obj` is an Array callback will be called passing | |
| * the value, index, and complete array for each item. | |
| * | |
| * If 'obj' is an Object callback will be called passing | |
| * the value, key, and complete object for each property. | |
| * | |
| * @param {Object|Array} obj The object to iterate | |
| * @param {Function} fn The callback to invoke for each item | |
| */ | |
| function forEach(obj, fn) { | |
| // Don't bother if no value provided | |
| if (obj === null || typeof obj === 'undefined') { | |
| return; | |
| } | |
| // Force an array if not already something iterable | |
| if (typeof obj !== 'object' && !isArray(obj)) { | |
| /*eslint no-param-reassign:0*/ | |
| obj = [obj]; | |
| } | |
| if (isArray(obj)) { | |
| // Iterate over array values | |
| for (var i = 0, l = obj.length; i < l; i++) { | |
| fn.call(null, obj[i], i, obj); | |
| } | |
| } else { | |
| // Iterate over object keys | |
| for (var key in obj) { | |
| if (obj.hasOwnProperty(key)) { | |
| fn.call(null, obj[key], key, obj); | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Accepts varargs expecting each argument to be an object, then | |
| * immutably merges the properties of each object and returns result. | |
| * | |
| * When multiple objects contain the same key the later object in | |
| * the arguments list will take precedence. | |
| * | |
| * Example: | |
| * | |
| * ```js | |
| * var result = merge({foo: 123}, {foo: 456}); | |
| * console.log(result.foo); // outputs 456 | |
| * ``` | |
| * | |
| * @param {Object} obj1 Object to merge | |
| * @returns {Object} Result of all merge properties | |
| */ | |
| function merge(/* obj1, obj2, obj3, ... */) { | |
| var result = {}; | |
| function assignValue(val, key) { | |
| if (typeof result[key] === 'object' && typeof val === 'object') { | |
| result[key] = merge(result[key], val); | |
| } else { | |
| result[key] = val; | |
| } | |
| } | |
| for (var i = 0, l = arguments.length; i < l; i++) { | |
| forEach(arguments[i], assignValue); | |
| } | |
| return result; | |
| } | |
| module.exports = { | |
| isArray: isArray, | |
| isArrayBuffer: isArrayBuffer, | |
| isFormData: isFormData, | |
| isArrayBufferView: isArrayBufferView, | |
| isString: isString, | |
| isNumber: isNumber, | |
| isObject: isObject, | |
| isUndefined: isUndefined, | |
| isDate: isDate, | |
| isFile: isFile, | |
| isBlob: isBlob, | |
| isStandardBrowserEnv: isStandardBrowserEnv, | |
| forEach: forEach, | |
| merge: merge, | |
| trim: trim | |
| }; | |
| /***/ }, | |
| /* 5 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| /* WEBPACK VAR INJECTION */(function(process) {'use strict'; | |
| /** | |
| * Dispatch a request to the server using whichever adapter | |
| * is supported by the current environment. | |
| * | |
| * @param {object} config The config that is to be used for the request | |
| * @returns {Promise} The Promise to be fulfilled | |
| */ | |
| module.exports = function dispatchRequest(config) { | |
| return new Promise(function executor(resolve, reject) { | |
| try { | |
| var adapter; | |
| if (typeof config.adapter === 'function') { | |
| // For custom adapter support | |
| adapter = config.adapter; | |
| } else if (typeof XMLHttpRequest !== 'undefined') { | |
| // For browsers use XHR adapter | |
| adapter = __webpack_require__(7); | |
| } else if (typeof process !== 'undefined') { | |
| // For node use HTTP adapter | |
| adapter = __webpack_require__(7); | |
| } | |
| if (typeof adapter === 'function') { | |
| adapter(resolve, reject, config); | |
| } | |
| } catch (e) { | |
| reject(e); | |
| } | |
| }); | |
| }; | |
| /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6))) | |
| /***/ }, | |
| /* 6 */ | |
| /***/ function(module, exports) { | |
| // shim for using process in browser | |
| var process = module.exports = {}; | |
| var queue = []; | |
| var draining = false; | |
| var currentQueue; | |
| var queueIndex = -1; | |
| function cleanUpNextTick() { | |
| draining = false; | |
| if (currentQueue.length) { | |
| queue = currentQueue.concat(queue); | |
| } else { | |
| queueIndex = -1; | |
| } | |
| if (queue.length) { | |
| drainQueue(); | |
| } | |
| } | |
| function drainQueue() { | |
| if (draining) { | |
| return; | |
| } | |
| var timeout = setTimeout(cleanUpNextTick); | |
| draining = true; | |
| var len = queue.length; | |
| while(len) { | |
| currentQueue = queue; | |
| queue = []; | |
| while (++queueIndex < len) { | |
| if (currentQueue) { | |
| currentQueue[queueIndex].run(); | |
| } | |
| } | |
| queueIndex = -1; | |
| len = queue.length; | |
| } | |
| currentQueue = null; | |
| draining = false; | |
| clearTimeout(timeout); | |
| } | |
| process.nextTick = function (fun) { | |
| var args = new Array(arguments.length - 1); | |
| if (arguments.length > 1) { | |
| for (var i = 1; i < arguments.length; i++) { | |
| args[i - 1] = arguments[i]; | |
| } | |
| } | |
| queue.push(new Item(fun, args)); | |
| if (queue.length === 1 && !draining) { | |
| setTimeout(drainQueue, 0); | |
| } | |
| }; | |
| // v8 likes predictible objects | |
| function Item(fun, array) { | |
| this.fun = fun; | |
| this.array = array; | |
| } | |
| Item.prototype.run = function () { | |
| this.fun.apply(null, this.array); | |
| }; | |
| process.title = 'browser'; | |
| process.browser = true; | |
| process.env = {}; | |
| process.argv = []; | |
| process.version = ''; // empty string to avoid regexp issues | |
| process.versions = {}; | |
| function noop() {} | |
| process.on = noop; | |
| process.addListener = noop; | |
| process.once = noop; | |
| process.off = noop; | |
| process.removeListener = noop; | |
| process.removeAllListeners = noop; | |
| process.emit = noop; | |
| process.binding = function (name) { | |
| throw new Error('process.binding is not supported'); | |
| }; | |
| process.cwd = function () { return '/' }; | |
| process.chdir = function (dir) { | |
| throw new Error('process.chdir is not supported'); | |
| }; | |
| process.umask = function() { return 0; }; | |
| /***/ }, | |
| /* 7 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| 'use strict'; | |
| var utils = __webpack_require__(4); | |
| var buildURL = __webpack_require__(8); | |
| var parseHeaders = __webpack_require__(9); | |
| var transformData = __webpack_require__(10); | |
| var isURLSameOrigin = __webpack_require__(11); | |
| var btoa = window.btoa || __webpack_require__(12); | |
| module.exports = function xhrAdapter(resolve, reject, config) { | |
| var requestData = config.data; | |
| var requestHeaders = config.headers; | |
| if (utils.isFormData(requestData)) { | |
| delete requestHeaders['Content-Type']; // Let the browser set it | |
| } | |
| var request = new XMLHttpRequest(); | |
| // For IE 8/9 CORS support | |
| // Only supports POST and GET calls and doesn't returns the response headers. | |
| if (window.XDomainRequest && !('withCredentials' in request) && !isURLSameOrigin(config.url)) { | |
| request = new window.XDomainRequest(); | |
| } | |
| // HTTP basic authentication | |
| if (config.auth) { | |
| var username = config.auth.username || ''; | |
| var password = config.auth.password || ''; | |
| requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password); | |
| } | |
| request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true); | |
| // Set the request timeout in MS | |
| request.timeout = config.timeout; | |
| // Listen for ready state | |
| request.onload = function handleLoad() { | |
| if (!request) { | |
| return; | |
| } | |
| // Prepare the response | |
| var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null; | |
| var responseData = ['text', ''].indexOf(config.responseType || '') !== -1 ? request.responseText : request.response; | |
| var response = { | |
| data: transformData( | |
| responseData, | |
| responseHeaders, | |
| config.transformResponse | |
| ), | |
| // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201) | |
| status: request.status === 1223 ? 204 : request.status, | |
| statusText: request.status === 1223 ? 'No Content' : request.statusText, | |
| headers: responseHeaders, | |
| config: config | |
| }; | |
| // Resolve or reject the Promise based on the status | |
| ((response.status >= 200 && response.status < 300) || | |
| (!('status' in request) && response.responseText) ? | |
| resolve : | |
| reject)(response); | |
| // Clean up request | |
| request = null; | |
| }; | |
| // Handle low level network errors | |
| request.onerror = function handleError() { | |
| // Real errors are hidden from us by the browser | |
| // onerror should only fire if it's a network error | |
| reject(new Error('Network Error')); | |
| // Clean up request | |
| request = null; | |
| }; | |
| // Add xsrf header | |
| // This is only done if running in a standard browser environment. | |
| // Specifically not if we're in a web worker, or react-native. | |
| if (utils.isStandardBrowserEnv()) { | |
| var cookies = __webpack_require__(13); | |
| // Add xsrf header | |
| var xsrfValue = config.withCredentials || isURLSameOrigin(config.url) ? | |
| cookies.read(config.xsrfCookieName) : | |
| undefined; | |
| if (xsrfValue) { | |
| requestHeaders[config.xsrfHeaderName] = xsrfValue; | |
| } | |
| } | |
| // Add headers to the request | |
| if ('setRequestHeader' in request) { | |
| utils.forEach(requestHeaders, function setRequestHeader(val, key) { | |
| if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') { | |
| // Remove Content-Type if data is undefined | |
| delete requestHeaders[key]; | |
| } else { | |
| // Otherwise add header to the request | |
| request.setRequestHeader(key, val); | |
| } | |
| }); | |
| } | |
| // Add withCredentials to request if needed | |
| if (config.withCredentials) { | |
| request.withCredentials = true; | |
| } | |
| // Add responseType to request if needed | |
| if (config.responseType) { | |
| try { | |
| request.responseType = config.responseType; | |
| } catch (e) { | |
| if (request.responseType !== 'json') { | |
| throw e; | |
| } | |
| } | |
| } | |
| if (utils.isArrayBuffer(requestData)) { | |
| requestData = new DataView(requestData); | |
| } | |
| // Send the request | |
| request.send(requestData); | |
| }; | |
| /***/ }, | |
| /* 8 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| 'use strict'; | |
| var utils = __webpack_require__(4); | |
| function encode(val) { | |
| return encodeURIComponent(val). | |
| replace(/%40/gi, '@'). | |
| replace(/%3A/gi, ':'). | |
| replace(/%24/g, '$'). | |
| replace(/%2C/gi, ','). | |
| replace(/%20/g, '+'). | |
| replace(/%5B/gi, '['). | |
| replace(/%5D/gi, ']'); | |
| } | |
| /** | |
| * Build a URL by appending params to the end | |
| * | |
| * @param {string} url The base of the url (e.g., http://www.google.com) | |
| * @param {object} [params] The params to be appended | |
| * @returns {string} The formatted url | |
| */ | |
| module.exports = function buildURL(url, params, paramsSerializer) { | |
| /*eslint no-param-reassign:0*/ | |
| if (!params) { | |
| return url; | |
| } | |
| var serializedParams; | |
| if (paramsSerializer) { | |
| serializedParams = paramsSerializer(params); | |
| } else { | |
| var parts = []; | |
| utils.forEach(params, function serialize(val, key) { | |
| if (val === null || typeof val === 'undefined') { | |
| return; | |
| } | |
| if (utils.isArray(val)) { | |
| key = key + '[]'; | |
| } | |
| if (!utils.isArray(val)) { | |
| val = [val]; | |
| } | |
| utils.forEach(val, function parseValue(v) { | |
| if (utils.isDate(v)) { | |
| v = v.toISOString(); | |
| } else if (utils.isObject(v)) { | |
| v = JSON.stringify(v); | |
| } | |
| parts.push(encode(key) + '=' + encode(v)); | |
| }); | |
| }); | |
| serializedParams = parts.join('&'); | |
| } | |
| if (serializedParams) { | |
| url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams; | |
| } | |
| return url; | |
| }; | |
| /***/ }, | |
| /* 9 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| 'use strict'; | |
| var utils = __webpack_require__(4); | |
| /** | |
| * Parse headers into an object | |
| * | |
| * ``` | |
| * Date: Wed, 27 Aug 2014 08:58:49 GMT | |
| * Content-Type: application/json | |
| * Connection: keep-alive | |
| * Transfer-Encoding: chunked | |
| * ``` | |
| * | |
| * @param {String} headers Headers needing to be parsed | |
| * @returns {Object} Headers parsed into an object | |
| */ | |
| module.exports = function parseHeaders(headers) { | |
| var parsed = {}; | |
| var key; | |
| var val; | |
| var i; | |
| if (!headers) { return parsed; } | |
| utils.forEach(headers.split('\n'), function parser(line) { | |
| i = line.indexOf(':'); | |
| key = utils.trim(line.substr(0, i)).toLowerCase(); | |
| val = utils.trim(line.substr(i + 1)); | |
| if (key) { | |
| parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val; | |
| } | |
| }); | |
| return parsed; | |
| }; | |
| /***/ }, | |
| /* 10 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| 'use strict'; | |
| var utils = __webpack_require__(4); | |
| /** | |
| * Transform the data for a request or a response | |
| * | |
| * @param {Object|String} data The data to be transformed | |
| * @param {Array} headers The headers for the request or response | |
| * @param {Array|Function} fns A single function or Array of functions | |
| * @returns {*} The resulting transformed data | |
| */ | |
| module.exports = function transformData(data, headers, fns) { | |
| /*eslint no-param-reassign:0*/ | |
| utils.forEach(fns, function transform(fn) { | |
| data = fn(data, headers); | |
| }); | |
| return data; | |
| }; | |
| /***/ }, | |
| /* 11 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| 'use strict'; | |
| var utils = __webpack_require__(4); | |
| module.exports = ( | |
| utils.isStandardBrowserEnv() ? | |
| // Standard browser envs have full support of the APIs needed to test | |
| // whether the request URL is of the same origin as current location. | |
| (function standardBrowserEnv() { | |
| var msie = /(msie|trident)/i.test(navigator.userAgent); | |
| var urlParsingNode = document.createElement('a'); | |
| var originURL; | |
| /** | |
| * Parse a URL to discover it's components | |
| * | |
| * @param {String} url The URL to be parsed | |
| * @returns {Object} | |
| */ | |
| function resolveURL(url) { | |
| var href = url; | |
| if (msie) { | |
| // IE needs attribute set twice to normalize properties | |
| urlParsingNode.setAttribute('href', href); | |
| href = urlParsingNode.href; | |
| } | |
| urlParsingNode.setAttribute('href', href); | |
| // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils | |
| return { | |
| href: urlParsingNode.href, | |
| protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '', | |
| host: urlParsingNode.host, | |
| search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '', | |
| hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '', | |
| hostname: urlParsingNode.hostname, | |
| port: urlParsingNode.port, | |
| pathname: (urlParsingNode.pathname.charAt(0) === '/') ? | |
| urlParsingNode.pathname : | |
| '/' + urlParsingNode.pathname | |
| }; | |
| } | |
| originURL = resolveURL(window.location.href); | |
| /** | |
| * Determine if a URL shares the same origin as the current location | |
| * | |
| * @param {String} requestURL The URL to test | |
| * @returns {boolean} True if URL shares the same origin, otherwise false | |
| */ | |
| return function isURLSameOrigin(requestURL) { | |
| var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL; | |
| return (parsed.protocol === originURL.protocol && | |
| parsed.host === originURL.host); | |
| }; | |
| })() : | |
| // Non standard browser envs (web workers, react-native) lack needed support. | |
| (function nonStandardBrowserEnv() { | |
| return function isURLSameOrigin() { | |
| return true; | |
| }; | |
| })() | |
| ); | |
| /***/ }, | |
| /* 12 */ | |
| /***/ function(module, exports) { | |
| 'use strict'; | |
| // btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js | |
| var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; | |
| function InvalidCharacterError(message) { | |
| this.message = message; | |
| } | |
| InvalidCharacterError.prototype = new Error; | |
| InvalidCharacterError.prototype.code = 5; | |
| InvalidCharacterError.prototype.name = 'InvalidCharacterError'; | |
| function btoa(input) { | |
| var str = String(input); | |
| var output = ''; | |
| for ( | |
| // initialize result and counter | |
| var block, charCode, idx = 0, map = chars; | |
| // if the next str index does not exist: | |
| // change the mapping table to "=" | |
| // check if d has no fractional digits | |
| str.charAt(idx | 0) || (map = '=', idx % 1); | |
| // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8 | |
| output += map.charAt(63 & block >> 8 - idx % 1 * 8) | |
| ) { | |
| charCode = str.charCodeAt(idx += 3 / 4); | |
| if (charCode > 0xFF) { | |
| throw new InvalidCharacterError('INVALID_CHARACTER_ERR: DOM Exception 5'); | |
| } | |
| block = block << 8 | charCode; | |
| } | |
| return output; | |
| } | |
| module.exports = btoa; | |
| /***/ }, | |
| /* 13 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| 'use strict'; | |
| var utils = __webpack_require__(4); | |
| module.exports = ( | |
| utils.isStandardBrowserEnv() ? | |
| // Standard browser envs support document.cookie | |
| (function standardBrowserEnv() { | |
| return { | |
| write: function write(name, value, expires, path, domain, secure) { | |
| var cookie = []; | |
| cookie.push(name + '=' + encodeURIComponent(value)); | |
| if (utils.isNumber(expires)) { | |
| cookie.push('expires=' + new Date(expires).toGMTString()); | |
| } | |
| if (utils.isString(path)) { | |
| cookie.push('path=' + path); | |
| } | |
| if (utils.isString(domain)) { | |
| cookie.push('domain=' + domain); | |
| } | |
| if (secure === true) { | |
| cookie.push('secure'); | |
| } | |
| document.cookie = cookie.join('; '); | |
| }, | |
| read: function read(name) { | |
| var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)')); | |
| return (match ? decodeURIComponent(match[3]) : null); | |
| }, | |
| remove: function remove(name) { | |
| this.write(name, '', Date.now() - 86400000); | |
| } | |
| }; | |
| })() : | |
| // Non standard browser env (web workers, react-native) lack needed support. | |
| (function nonStandardBrowserEnv() { | |
| return { | |
| write: function write() {}, | |
| read: function read() { return null; }, | |
| remove: function remove() {} | |
| }; | |
| })() | |
| ); | |
| /***/ }, | |
| /* 14 */ | |
| /***/ function(module, exports, __webpack_require__) { | |
| 'use strict'; | |
| var utils = __webpack_require__(4); | |
| function InterceptorManager() { | |
| this.handlers = []; | |
| } | |
| /** | |
| * Add a new interceptor to the stack | |
| * | |
| * @param {Function} fulfilled The function to handle `then` for a `Promise` | |
| * @param {Function} rejected The function to handle `reject` for a `Promise` | |
| * | |
| * @return {Number} An ID used to remove interceptor later | |
| */ | |
| InterceptorManager.prototype.use = function use(fulfilled, rejected) { | |
| this.handlers.push({ | |
| fulfilled: fulfilled, | |
| rejected: rejected | |
| }); | |
| return this.handlers.length - 1; | |
| }; | |
| /** | |
| * Remove an interceptor from the stack | |
| * | |
| * @param {Number} id The ID that was returned by `use` | |
| */ | |
| InterceptorManager.prototype.eject = function eject(id) { | |
| if (this.handlers[id]) { | |
| this.handlers[id] = null; | |
| } | |
| }; | |
| /** | |
| * Iterate over all the registered interceptors | |
| * | |
| * This method is particularly useful for skipping over any | |
| * interceptors that may have become `null` calling `eject`. | |
| * | |
| * @param {Function} fn The function to call for each interceptor | |
| */ | |
| InterceptorManager.prototype.forEach = function forEach(fn) { | |
| utils.forEach(this.handlers, function forEachHandler(h) { | |
| if (h !== null) { | |
| fn(h); | |
| } | |
| }); | |
| }; | |
| module.exports = InterceptorManager; | |
| /***/ }, | |
| /* 15 */ | |
| /***/ function(module, exports) { | |
| 'use strict'; | |
| /** | |
| * Determines whether the specified URL is absolute | |
| * | |
| * @param {string} url The URL to test | |
| * @returns {boolean} True if the specified URL is absolute, otherwise false | |
| */ | |
| module.exports = function isAbsoluteURL(url) { | |
| // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL). | |
| // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed | |
| // by any combination of letters, digits, plus, period, or hyphen. | |
| return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url); | |
| }; | |
| /***/ }, | |
| /* 16 */ | |
| /***/ function(module, exports) { | |
| 'use strict'; | |
| /** | |
| * Creates a new URL by combining the specified URLs | |
| * | |
| * @param {string} baseURL The base URL | |
| * @param {string} relativeURL The relative URL | |
| * @returns {string} The combined URL | |
| */ | |
| module.exports = function combineURLs(baseURL, relativeURL) { | |
| return baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, ''); | |
| }; | |
| /***/ }, | |
| /* 17 */ | |
| /***/ function(module, exports) { | |
| 'use strict'; | |
| module.exports = function bind(fn, thisArg) { | |
| return function wrap() { | |
| var args = new Array(arguments.length); | |
| for (var i = 0; i < args.length; i++) { | |
| args[i] = arguments[i]; | |
| } | |
| return fn.apply(thisArg, args); | |
| }; | |
| }; | |
| /***/ }, | |
| /* 18 */ | |
| /***/ function(module, exports) { | |
| 'use strict'; | |
| /** | |
| * Syntactic sugar for invoking a function and expanding an array for arguments. | |
| * | |
| * Common use case would be to use `Function.prototype.apply`. | |
| * | |
| * ```js | |
| * function f(x, y, z) {} | |
| * var args = [1, 2, 3]; | |
| * f.apply(null, args); | |
| * ``` | |
| * | |
| * With `spread` this example can be re-written. | |
| * | |
| * ```js | |
| * spread(function(x, y, z) {})([1, 2, 3]); | |
| * ``` | |
| * | |
| * @param {Function} callback | |
| * @returns {Function} | |
| */ | |
| module.exports = function spread(callback) { | |
| return function wrap(arr) { | |
| return callback.apply(null, arr); | |
| }; | |
| }; | |
| /***/ } | |
| /******/ ]); | |
| },{}]},{},[]) | |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/tmp/xenia-driver116318-14889-2vg5id/node_modules/xenia-driver/dist/index.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","module.exports =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar _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; };\n\n\tvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t/**\n\t * Module dependencies\n\t */\n\n\tvar _axios = __webpack_require__(1);\n\n\tvar _axios2 = _interopRequireDefault(_axios);\n\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n\tfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n\t/**\n\t * Module constants\n\t */\n\n\tvar dataSchema = {\n\t  name: 'my_query',\n\t  desc: 'made with xenia driver',\n\t  enabled: true\n\t};\n\n\tvar querySchema = {\n\t  name: 'my_query',\n\t  type: 'pipeline',\n\t  collection: 'user_statistics',\n\t  return: true\n\t};\n\n\t/**\n\t * Driver Class\n\t * @class\n\t */\n\n\tvar XeniaDriver = function () {\n\n\t  /**\n\t   * Initialize the driver\n\t   * @constructor\n\t   * @param {string} base url - Xenia base url\n\t   * @param {object | string} Auth - Xenia basic authentication credentials\n\t   * @param {object} parameters - extra parameters; optional\n\t   * @param {object} request parameters - overrides extra parameters; optional\n\t    */\n\n\t  function XeniaDriver(baseURL, auth) {\n\t    var params = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];\n\t    var reqParams = arguments[3];\n\n\t    _classCallCheck(this, XeniaDriver);\n\n\t    if ('string' !== typeof baseURL) {\n\t      throw new Error('A base url is needed for the Xenia Driver to work.');\n\t    }\n\n\t    if ('object' !== (typeof auth === 'undefined' ? 'undefined' : _typeof(auth)) && 'string' !== typeof auth) {\n\t      throw new Error('An authorization object ({username, password}) or a Basic Authentication string is needed for the Xenia Driver to work.');\n\t    }\n\n\t    this._baseURL = baseURL;\n\t    this._auth = auth;\n\t    this._params = params;\n\t    var headers = {};\n\n\t    if (typeof auth === 'string') {\n\t      headers.Authorization = auth;\n\t      auth = null;\n\t    }\n\n\t    // Initialize the request instance\n\t    this._request = _axios2.default.create({\n\t      baseURL: baseURL,\n\t      auth: auth,\n\t      headers: headers,\n\t      timeout: 10000\n\t    });\n\n\t    // Initialize the query\n\t    this._data = Object.assign({}, dataSchema, { params: [], queries: [] }, params.defaults, reqParams);\n\n\t    if (!reqParams) {\n\t      this.addQuery(params);\n\t    }\n\n\t    return this;\n\t  }\n\n\t  /**\n\t   * Commit the current query\n\t   * @private\n\t   */\n\n\t  _createClass(XeniaDriver, [{\n\t    key: '_commitQuery',\n\t    value: function _commitQuery() {\n\t      if (this._query) {\n\t        this._query.commands = this._commands;\n\t        this._query._pendingJoin = this._pendingJoin;\n\t        this._data.queries.push(this._query);\n\t      }\n\t      this._query = null;\n\t      this._pendingJoin = null;\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Initialize a query\n\t     * @param {object} query object - optional\n\t     */\n\n\t  }, {\n\t    key: 'addQuery',\n\t    value: function addQuery() {\n\t      var queryData = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n\t      var rand = Math.floor(Math.random() * 9999);\n\t      this._commitQuery();\n\t      this._query = Object.assign({}, querySchema, queryData, { name: 'my_query_' + rand, commands: [] });\n\t      this._commands = [];\n\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Set the collection for the current query\n\t     * @param {string} collection name\n\t     */\n\n\t  }, {\n\t    key: 'collection',\n\t    value: function collection() {\n\t      var name = arguments.length <= 0 || arguments[0] === undefined ? 'user_statistics' : arguments[0];\n\n\t      this._query.collection = name;\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Executes the request\n\t     * @api private\n\t     * @param {string} query name - optional\n\t     * @param {object} query parameters - optional\n\t     */\n\n\t  }, {\n\t    key: '_execRequest',\n\t    value: function _execRequest() {\n\t      var method = arguments.length <= 0 || arguments[0] === undefined ? 'post' : arguments[0];\n\n\t      var _this = this;\n\n\t      var path = arguments.length <= 1 || arguments[1] === undefined ? '/exec' : arguments[1];\n\t      var data = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];\n\n\t      return this._request[method](path, data).then(function (res) {\n\t        return res.data;\n\t      })\n\n\t      // perform join match\n\t      .then(function (data) {\n\t        if (!data.results) return data;\n\t        data.results.forEach(function (res, i) {\n\t          if (!_this._data.queries[i]) return;\n\t          var pendingJoin = _this._data.queries[i]._pendingJoin;\n\t          if (pendingJoin) {\n\t            res.Docs = res.Docs.map(function (doc) {\n\t              var match = data.results[i + 1].Docs.find(function (nextDoc) {\n\t                return nextDoc[pendingJoin.field] === doc[pendingJoin.matchingField];\n\t              });\n\t              doc[pendingJoin.name] = match;\n\t              return doc;\n\t            });\n\t          }\n\t        });\n\t        return data;\n\t      });\n\t    }\n\n\t    /**\n\t     * Executes the request\n\t     * @param {string} query name - optional\n\t     * @param {object} query parameters - optional\n\t     */\n\n\t  }, {\n\t    key: 'exec',\n\t    value: function exec(queryName) {\n\t      var params = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n\t      if ('string' !== typeof queryName) {\n\t        this._commitQuery();\n\t        return this._execRequest('post', '/exec', this._data);\n\t      } else {\n\t        return this._execRequest('get', '/exec/' + queryName, { params: params });\n\t      }\n\t    }\n\n\t    /**\n\t     * Get a list of available queries\n\t     */\n\n\t  }, {\n\t    key: 'getQueries',\n\t    value: function getQueries() {\n\t      return this._execRequest('get', '/query');\n\t    }\n\n\t    /**\n\t     * Get a specific queryset document\n\t     * @param {string} query name\n\t     */\n\n\t  }, {\n\t    key: 'getQuery',\n\t    value: function getQuery(name) {\n\t      return this._execRequest('get', '/query/' + name);\n\t    }\n\n\t    /**\n\t     * Save a query into xenia instead of executing it\n\t     */\n\n\t  }, {\n\t    key: 'saveQuery',\n\t    value: function saveQuery(name) {\n\t      if (name) {\n\t        this._data.name = name;\n\t      }\n\n\t      return this._request.put('/query', this._data).then(function (res) {\n\t        return res.data;\n\t      });\n\t    }\n\n\t    /**\n\t     * Delete a query from xenia\n\t     * @param {String} name\n\t     */\n\n\t  }, {\n\t    key: 'deleteQuery',\n\t    value: function deleteQuery(name) {\n\t      if (name) {\n\t        this._data.name = name;\n\t      }\n\n\t      return this._request.delete('/query/' + name).then(function (res) {\n\t        return res.data;\n\t      });\n\t    }\n\n\t    /**\n\t     * Limit the amount of retrieved documents\n\t     * @param {number} limit - default: 20\n\t     */\n\n\t  }, {\n\t    key: 'limit',\n\t    value: function limit() {\n\t      var n = arguments.length <= 0 || arguments[0] === undefined ? 20 : arguments[0];\n\n\t      this._commands.push({ '$limit': n });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Skip the first n documents\n\t     * @param {number} skip - default: 0\n\t     */\n\n\t  }, {\n\t    key: 'skip',\n\t    value: function skip() {\n\t      var n = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0];\n\n\t      this._commands.push({ '$skip': n });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Return a document sample from the collection\n\t     * @param {number} size - default: 20\n\t     */\n\n\t  }, {\n\t    key: 'sample',\n\t    value: function sample() {\n\t      var size = arguments.length <= 0 || arguments[0] === undefined ? 20 : arguments[0];\n\n\t      this._commands.push({ '$sample': { size: size } });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Include and exclude fields from the result\n\t     * @param {object} fields\n\t     */\n\n\t  }, {\n\t    key: 'project',\n\t    value: function project() {\n\t      var fields = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n\t      this._commands.push({ '$project': fields });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Whitelist retrieved fields\n\t     * @param {array} fields\n\t     */\n\n\t  }, {\n\t    key: 'include',\n\t    value: function include() {\n\t      var fields = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];\n\n\t      var obj = {};\n\t      fields.forEach(function (field) {\n\t        return obj[field] = true;\n\t      });\n\t      this._commands.push({ '$project': obj });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Blacklist retrieved fields\n\t     * @param {array} fields\n\t     */\n\n\t  }, {\n\t    key: 'exclude',\n\t    value: function exclude() {\n\t      var fields = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];\n\n\t      var obj = {};\n\t      fields.forEach(function (field) {\n\t        return obj[field] = false;\n\t      });\n\t      this._commands.push({ '$project': obj });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Performs a match command\n\t     * @param {object} match\n\t     */\n\n\t  }, {\n\t    key: 'match',\n\t    value: function match() {\n\t      var query = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n\t      this._commands.push({ '$match': query });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Performs a redact command\n\t     * @param {object} match\n\t     */\n\n\t  }, {\n\t    key: 'redact',\n\t    value: function redact() {\n\t      var query = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n\t      this._commands.push({ '$redact': query });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Deconstructs an array field from the input documents to\n\t     * output a document for each element\n\t     * @param {string} path\n\t     * @param {string} include array index - optional\n\t     * @param {boolean} preserve null and empty arrays - optional\n\t     */\n\n\t  }, {\n\t    key: 'unwind',\n\t    value: function unwind() {\n\t      var path = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\t      var includeArrayIndex = arguments[1];\n\t      var preserveNullAndEmptyArrays = arguments[2];\n\n\t      this._commands.push({ '$unwind': { path: path, includeArrayIndex: includeArrayIndex, preserveNullAndEmptyArrays: preserveNullAndEmptyArrays } });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Group documents\n\t     * @param {object} group\n\t     */\n\n\t  }, {\n\t    key: 'group',\n\t    value: function group() {\n\t      var groups = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n\t      this._commands.push({ '$group': groups });\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Sort documents\n\t     * @param {object|array} sorting data\n\t     */\n\n\t  }, {\n\t    key: 'sort',\n\t    value: function sort() {\n\t      var order = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n\t      if (Array.isArray(order)) {\n\t        this._commands.push({ '$sort': _defineProperty({}, order[0], order[1]) });\n\t      } else {\n\t        this._commands.push({ '$sort': order });\n\t      }\n\t      return this;\n\t    }\n\n\t    /**\n\t     * Creates a new query joining the actual one using the save method\n\t     * from Xenia\n\t     * @param {string} collection\n\t     * @param {string} field - default: _id\n\t     * @param {string} matching field - default: field\n\t     * @param {sting} join parameter name - default: 'list'\n\t     */\n\n\t  }, {\n\t    key: 'join',\n\t    value: function join(collection) {\n\t      var field = arguments.length <= 1 || arguments[1] === undefined ? '_id' : arguments[1];\n\t      var matchingField = arguments[2];\n\t      var name = arguments.length <= 3 || arguments[3] === undefined ? 'list' : arguments[3];\n\n\t      if (!matchingField) {\n\t        matchingField = field;\n\t      }\n\n\t      this._pendingJoin = { field: field, matchingField: matchingField, name: name };\n\t      this._commands.push({ '$save': { '$map': name } });\n\t      this.addQuery().collection(collection).match(_defineProperty({}, field, { '$in': '#data.*:' + name + '.' + matchingField }));\n\t      return this;\n\t    }\n\t  }]);\n\n\t  return XeniaDriver;\n\t}();\n\n\t/**\n\t * Expose a function that just create a new XeniaDriver instance\n\t * so you don't need to use the `new` keyword ¯\\_(ツ)_/¯\n\t */\n\n\tmodule.exports = function (url, auth, params) {\n\t  return function (reqParams) {\n\t    return new XeniaDriver(url, auth, params, reqParams);\n\t  };\n\t};\n\n/***/ },\n/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = __webpack_require__(2);\n\n/***/ },\n/* 2 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar defaults = __webpack_require__(3);\n\tvar utils = __webpack_require__(4);\n\tvar dispatchRequest = __webpack_require__(5);\n\tvar InterceptorManager = __webpack_require__(14);\n\tvar isAbsoluteURL = __webpack_require__(15);\n\tvar combineURLs = __webpack_require__(16);\n\tvar bind = __webpack_require__(17);\n\tvar transformData = __webpack_require__(10);\n\n\tfunction Axios(defaultConfig) {\n\t  this.defaults = utils.merge({}, defaultConfig);\n\t  this.interceptors = {\n\t    request: new InterceptorManager(),\n\t    response: new InterceptorManager()\n\t  };\n\t}\n\n\tAxios.prototype.request = function request(config) {\n\t  /*eslint no-param-reassign:0*/\n\t  // Allow for axios('example/url'[, config]) a la fetch API\n\t  if (typeof config === 'string') {\n\t    config = utils.merge({\n\t      url: arguments[0]\n\t    }, arguments[1]);\n\t  }\n\n\t  config = utils.merge(defaults, this.defaults, { method: 'get' }, config);\n\n\t  // Support baseURL config\n\t  if (config.baseURL && !isAbsoluteURL(config.url)) {\n\t    config.url = combineURLs(config.baseURL, config.url);\n\t  }\n\n\t  // Don't allow overriding defaults.withCredentials\n\t  config.withCredentials = config.withCredentials || this.defaults.withCredentials;\n\n\t  // Transform request data\n\t  config.data = transformData(\n\t    config.data,\n\t    config.headers,\n\t    config.transformRequest\n\t  );\n\n\t  // Flatten headers\n\t  config.headers = utils.merge(\n\t    config.headers.common || {},\n\t    config.headers[config.method] || {},\n\t    config.headers || {}\n\t  );\n\n\t  utils.forEach(\n\t    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n\t    function cleanHeaderConfig(method) {\n\t      delete config.headers[method];\n\t    }\n\t  );\n\n\t  // Hook up interceptors middleware\n\t  var chain = [dispatchRequest, undefined];\n\t  var promise = Promise.resolve(config);\n\n\t  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n\t    chain.unshift(interceptor.fulfilled, interceptor.rejected);\n\t  });\n\n\t  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n\t    chain.push(interceptor.fulfilled, interceptor.rejected);\n\t  });\n\n\t  while (chain.length) {\n\t    promise = promise.then(chain.shift(), chain.shift());\n\t  }\n\n\t  return promise;\n\t};\n\n\tvar defaultInstance = new Axios(defaults);\n\tvar axios = module.exports = bind(Axios.prototype.request, defaultInstance);\n\n\taxios.create = function create(defaultConfig) {\n\t  return new Axios(defaultConfig);\n\t};\n\n\t// Expose defaults\n\taxios.defaults = defaultInstance.defaults;\n\n\t// Expose all/spread\n\taxios.all = function all(promises) {\n\t  return Promise.all(promises);\n\t};\n\taxios.spread = __webpack_require__(18);\n\n\t// Expose interceptors\n\taxios.interceptors = defaultInstance.interceptors;\n\n\t// Provide aliases for supported request methods\n\tutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n\t  /*eslint func-names:0*/\n\t  Axios.prototype[method] = function(url, config) {\n\t    return this.request(utils.merge(config || {}, {\n\t      method: method,\n\t      url: url\n\t    }));\n\t  };\n\t  axios[method] = bind(Axios.prototype[method], defaultInstance);\n\t});\n\n\tutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n\t  /*eslint func-names:0*/\n\t  Axios.prototype[method] = function(url, data, config) {\n\t    return this.request(utils.merge(config || {}, {\n\t      method: method,\n\t      url: url,\n\t      data: data\n\t    }));\n\t  };\n\t  axios[method] = bind(Axios.prototype[method], defaultInstance);\n\t});\n\n\n/***/ },\n/* 3 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar utils = __webpack_require__(4);\n\n\tvar PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\n\tvar DEFAULT_CONTENT_TYPE = {\n\t  'Content-Type': 'application/x-www-form-urlencoded'\n\t};\n\n\tmodule.exports = {\n\t  transformRequest: [function transformResponseJSON(data, headers) {\n\t    if (utils.isFormData(data)) {\n\t      return data;\n\t    }\n\t    if (utils.isArrayBuffer(data)) {\n\t      return data;\n\t    }\n\t    if (utils.isArrayBufferView(data)) {\n\t      return data.buffer;\n\t    }\n\t    if (utils.isObject(data) && !utils.isFile(data) && !utils.isBlob(data)) {\n\t      // Set application/json if no Content-Type has been specified\n\t      if (!utils.isUndefined(headers)) {\n\t        utils.forEach(headers, function processContentTypeHeader(val, key) {\n\t          if (key.toLowerCase() === 'content-type') {\n\t            headers['Content-Type'] = val;\n\t          }\n\t        });\n\n\t        if (utils.isUndefined(headers['Content-Type'])) {\n\t          headers['Content-Type'] = 'application/json;charset=utf-8';\n\t        }\n\t      }\n\t      return JSON.stringify(data);\n\t    }\n\t    return data;\n\t  }],\n\n\t  transformResponse: [function transformResponseJSON(data) {\n\t    /*eslint no-param-reassign:0*/\n\t    if (typeof data === 'string') {\n\t      data = data.replace(PROTECTION_PREFIX, '');\n\t      try {\n\t        data = JSON.parse(data);\n\t      } catch (e) { /* Ignore */ }\n\t    }\n\t    return data;\n\t  }],\n\n\t  headers: {\n\t    common: {\n\t      'Accept': 'application/json, text/plain, */*'\n\t    },\n\t    patch: utils.merge(DEFAULT_CONTENT_TYPE),\n\t    post: utils.merge(DEFAULT_CONTENT_TYPE),\n\t    put: utils.merge(DEFAULT_CONTENT_TYPE)\n\t  },\n\n\t  timeout: 0,\n\n\t  xsrfCookieName: 'XSRF-TOKEN',\n\t  xsrfHeaderName: 'X-XSRF-TOKEN'\n\t};\n\n\n/***/ },\n/* 4 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\n\t/*global toString:true*/\n\n\t// utils is a library of generic helper functions non-specific to axios\n\n\tvar toString = Object.prototype.toString;\n\n\t/**\n\t * Determine if a value is an Array\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is an Array, otherwise false\n\t */\n\tfunction isArray(val) {\n\t  return toString.call(val) === '[object Array]';\n\t}\n\n\t/**\n\t * Determine if a value is an ArrayBuffer\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n\t */\n\tfunction isArrayBuffer(val) {\n\t  return toString.call(val) === '[object ArrayBuffer]';\n\t}\n\n\t/**\n\t * Determine if a value is a FormData\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is an FormData, otherwise false\n\t */\n\tfunction isFormData(val) {\n\t  return toString.call(val) === '[object FormData]';\n\t}\n\n\t/**\n\t * Determine if a value is a view on an ArrayBuffer\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n\t */\n\tfunction isArrayBufferView(val) {\n\t  var result;\n\t  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n\t    result = ArrayBuffer.isView(val);\n\t  } else {\n\t    result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n\t  }\n\t  return result;\n\t}\n\n\t/**\n\t * Determine if a value is a String\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is a String, otherwise false\n\t */\n\tfunction isString(val) {\n\t  return typeof val === 'string';\n\t}\n\n\t/**\n\t * Determine if a value is a Number\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is a Number, otherwise false\n\t */\n\tfunction isNumber(val) {\n\t  return typeof val === 'number';\n\t}\n\n\t/**\n\t * Determine if a value is undefined\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if the value is undefined, otherwise false\n\t */\n\tfunction isUndefined(val) {\n\t  return typeof val === 'undefined';\n\t}\n\n\t/**\n\t * Determine if a value is an Object\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is an Object, otherwise false\n\t */\n\tfunction isObject(val) {\n\t  return val !== null && typeof val === 'object';\n\t}\n\n\t/**\n\t * Determine if a value is a Date\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is a Date, otherwise false\n\t */\n\tfunction isDate(val) {\n\t  return toString.call(val) === '[object Date]';\n\t}\n\n\t/**\n\t * Determine if a value is a File\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is a File, otherwise false\n\t */\n\tfunction isFile(val) {\n\t  return toString.call(val) === '[object File]';\n\t}\n\n\t/**\n\t * Determine if a value is a Blob\n\t *\n\t * @param {Object} val The value to test\n\t * @returns {boolean} True if value is a Blob, otherwise false\n\t */\n\tfunction isBlob(val) {\n\t  return toString.call(val) === '[object Blob]';\n\t}\n\n\t/**\n\t * Trim excess whitespace off the beginning and end of a string\n\t *\n\t * @param {String} str The String to trim\n\t * @returns {String} The String freed of excess whitespace\n\t */\n\tfunction trim(str) {\n\t  return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n\t}\n\n\t/**\n\t * Determine if we're running in a standard browser environment\n\t *\n\t * This allows axios to run in a web worker, and react-native.\n\t * Both environments support XMLHttpRequest, but not fully standard globals.\n\t *\n\t * web workers:\n\t *  typeof window -> undefined\n\t *  typeof document -> undefined\n\t *\n\t * react-native:\n\t *  typeof document.createElement -> undefined\n\t */\n\tfunction isStandardBrowserEnv() {\n\t  return (\n\t    typeof window !== 'undefined' &&\n\t    typeof document !== 'undefined' &&\n\t    typeof document.createElement === 'function'\n\t  );\n\t}\n\n\t/**\n\t * Iterate over an Array or an Object invoking a function for each item.\n\t *\n\t * If `obj` is an Array callback will be called passing\n\t * the value, index, and complete array for each item.\n\t *\n\t * If 'obj' is an Object callback will be called passing\n\t * the value, key, and complete object for each property.\n\t *\n\t * @param {Object|Array} obj The object to iterate\n\t * @param {Function} fn The callback to invoke for each item\n\t */\n\tfunction forEach(obj, fn) {\n\t  // Don't bother if no value provided\n\t  if (obj === null || typeof obj === 'undefined') {\n\t    return;\n\t  }\n\n\t  // Force an array if not already something iterable\n\t  if (typeof obj !== 'object' && !isArray(obj)) {\n\t    /*eslint no-param-reassign:0*/\n\t    obj = [obj];\n\t  }\n\n\t  if (isArray(obj)) {\n\t    // Iterate over array values\n\t    for (var i = 0, l = obj.length; i < l; i++) {\n\t      fn.call(null, obj[i], i, obj);\n\t    }\n\t  } else {\n\t    // Iterate over object keys\n\t    for (var key in obj) {\n\t      if (obj.hasOwnProperty(key)) {\n\t        fn.call(null, obj[key], key, obj);\n\t      }\n\t    }\n\t  }\n\t}\n\n\t/**\n\t * Accepts varargs expecting each argument to be an object, then\n\t * immutably merges the properties of each object and returns result.\n\t *\n\t * When multiple objects contain the same key the later object in\n\t * the arguments list will take precedence.\n\t *\n\t * Example:\n\t *\n\t * ```js\n\t * var result = merge({foo: 123}, {foo: 456});\n\t * console.log(result.foo); // outputs 456\n\t * ```\n\t *\n\t * @param {Object} obj1 Object to merge\n\t * @returns {Object} Result of all merge properties\n\t */\n\tfunction merge(/* obj1, obj2, obj3, ... */) {\n\t  var result = {};\n\t  function assignValue(val, key) {\n\t    if (typeof result[key] === 'object' && typeof val === 'object') {\n\t      result[key] = merge(result[key], val);\n\t    } else {\n\t      result[key] = val;\n\t    }\n\t  }\n\n\t  for (var i = 0, l = arguments.length; i < l; i++) {\n\t    forEach(arguments[i], assignValue);\n\t  }\n\t  return result;\n\t}\n\n\tmodule.exports = {\n\t  isArray: isArray,\n\t  isArrayBuffer: isArrayBuffer,\n\t  isFormData: isFormData,\n\t  isArrayBufferView: isArrayBufferView,\n\t  isString: isString,\n\t  isNumber: isNumber,\n\t  isObject: isObject,\n\t  isUndefined: isUndefined,\n\t  isDate: isDate,\n\t  isFile: isFile,\n\t  isBlob: isBlob,\n\t  isStandardBrowserEnv: isStandardBrowserEnv,\n\t  forEach: forEach,\n\t  merge: merge,\n\t  trim: trim\n\t};\n\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(process) {'use strict';\n\n\t/**\n\t * Dispatch a request to the server using whichever adapter\n\t * is supported by the current environment.\n\t *\n\t * @param {object} config The config that is to be used for the request\n\t * @returns {Promise} The Promise to be fulfilled\n\t */\n\tmodule.exports = function dispatchRequest(config) {\n\t  return new Promise(function executor(resolve, reject) {\n\t    try {\n\t      var adapter;\n\n\t      if (typeof config.adapter === 'function') {\n\t        // For custom adapter support\n\t        adapter = config.adapter;\n\t      } else if (typeof XMLHttpRequest !== 'undefined') {\n\t        // For browsers use XHR adapter\n\t        adapter = __webpack_require__(7);\n\t      } else if (typeof process !== 'undefined') {\n\t        // For node use HTTP adapter\n\t        adapter = __webpack_require__(7);\n\t      }\n\n\t      if (typeof adapter === 'function') {\n\t        adapter(resolve, reject, config);\n\t      }\n\t    } catch (e) {\n\t      reject(e);\n\t    }\n\t  });\n\t};\n\n\n\t/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)))\n\n/***/ },\n/* 6 */\n/***/ function(module, exports) {\n\n\t// shim for using process in browser\n\n\tvar process = module.exports = {};\n\tvar queue = [];\n\tvar draining = false;\n\tvar currentQueue;\n\tvar queueIndex = -1;\n\n\tfunction cleanUpNextTick() {\n\t    draining = false;\n\t    if (currentQueue.length) {\n\t        queue = currentQueue.concat(queue);\n\t    } else {\n\t        queueIndex = -1;\n\t    }\n\t    if (queue.length) {\n\t        drainQueue();\n\t    }\n\t}\n\n\tfunction drainQueue() {\n\t    if (draining) {\n\t        return;\n\t    }\n\t    var timeout = setTimeout(cleanUpNextTick);\n\t    draining = true;\n\n\t    var len = queue.length;\n\t    while(len) {\n\t        currentQueue = queue;\n\t        queue = [];\n\t        while (++queueIndex < len) {\n\t            if (currentQueue) {\n\t                currentQueue[queueIndex].run();\n\t            }\n\t        }\n\t        queueIndex = -1;\n\t        len = queue.length;\n\t    }\n\t    currentQueue = null;\n\t    draining = false;\n\t    clearTimeout(timeout);\n\t}\n\n\tprocess.nextTick = function (fun) {\n\t    var args = new Array(arguments.length - 1);\n\t    if (arguments.length > 1) {\n\t        for (var i = 1; i < arguments.length; i++) {\n\t            args[i - 1] = arguments[i];\n\t        }\n\t    }\n\t    queue.push(new Item(fun, args));\n\t    if (queue.length === 1 && !draining) {\n\t        setTimeout(drainQueue, 0);\n\t    }\n\t};\n\n\t// v8 likes predictible objects\n\tfunction Item(fun, array) {\n\t    this.fun = fun;\n\t    this.array = array;\n\t}\n\tItem.prototype.run = function () {\n\t    this.fun.apply(null, this.array);\n\t};\n\tprocess.title = 'browser';\n\tprocess.browser = true;\n\tprocess.env = {};\n\tprocess.argv = [];\n\tprocess.version = ''; // empty string to avoid regexp issues\n\tprocess.versions = {};\n\n\tfunction noop() {}\n\n\tprocess.on = noop;\n\tprocess.addListener = noop;\n\tprocess.once = noop;\n\tprocess.off = noop;\n\tprocess.removeListener = noop;\n\tprocess.removeAllListeners = noop;\n\tprocess.emit = noop;\n\n\tprocess.binding = function (name) {\n\t    throw new Error('process.binding is not supported');\n\t};\n\n\tprocess.cwd = function () { return '/' };\n\tprocess.chdir = function (dir) {\n\t    throw new Error('process.chdir is not supported');\n\t};\n\tprocess.umask = function() { return 0; };\n\n\n/***/ },\n/* 7 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar utils = __webpack_require__(4);\n\tvar buildURL = __webpack_require__(8);\n\tvar parseHeaders = __webpack_require__(9);\n\tvar transformData = __webpack_require__(10);\n\tvar isURLSameOrigin = __webpack_require__(11);\n\tvar btoa = window.btoa || __webpack_require__(12);\n\n\tmodule.exports = function xhrAdapter(resolve, reject, config) {\n\t  var requestData = config.data;\n\t  var requestHeaders = config.headers;\n\n\t  if (utils.isFormData(requestData)) {\n\t    delete requestHeaders['Content-Type']; // Let the browser set it\n\t  }\n\n\t  var request = new XMLHttpRequest();\n\n\t  // For IE 8/9 CORS support\n\t  // Only supports POST and GET calls and doesn't returns the response headers.\n\t  if (window.XDomainRequest && !('withCredentials' in request) && !isURLSameOrigin(config.url)) {\n\t    request = new window.XDomainRequest();\n\t  }\n\n\t  // HTTP basic authentication\n\t  if (config.auth) {\n\t    var username = config.auth.username || '';\n\t    var password = config.auth.password || '';\n\t    requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n\t  }\n\n\t  request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);\n\n\t  // Set the request timeout in MS\n\t  request.timeout = config.timeout;\n\n\t  // Listen for ready state\n\t  request.onload = function handleLoad() {\n\t    if (!request) {\n\t      return;\n\t    }\n\t    // Prepare the response\n\t    var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n\t    var responseData = ['text', ''].indexOf(config.responseType || '') !== -1 ? request.responseText : request.response;\n\t    var response = {\n\t      data: transformData(\n\t        responseData,\n\t        responseHeaders,\n\t        config.transformResponse\n\t      ),\n\t      // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)\n\t      status: request.status === 1223 ? 204 : request.status,\n\t      statusText: request.status === 1223 ? 'No Content' : request.statusText,\n\t      headers: responseHeaders,\n\t      config: config\n\t    };\n\n\t    // Resolve or reject the Promise based on the status\n\t    ((response.status >= 200 && response.status < 300) ||\n\t     (!('status' in request) && response.responseText) ?\n\t      resolve :\n\t      reject)(response);\n\n\t    // Clean up request\n\t    request = null;\n\t  };\n\n\t  // Handle low level network errors\n\t  request.onerror = function handleError() {\n\t    // Real errors are hidden from us by the browser\n\t    // onerror should only fire if it's a network error\n\t    reject(new Error('Network Error'));\n\n\t    // Clean up request\n\t    request = null;\n\t  };\n\n\t  // Add xsrf header\n\t  // This is only done if running in a standard browser environment.\n\t  // Specifically not if we're in a web worker, or react-native.\n\t  if (utils.isStandardBrowserEnv()) {\n\t    var cookies = __webpack_require__(13);\n\n\t    // Add xsrf header\n\t    var xsrfValue = config.withCredentials || isURLSameOrigin(config.url) ?\n\t        cookies.read(config.xsrfCookieName) :\n\t        undefined;\n\n\t    if (xsrfValue) {\n\t      requestHeaders[config.xsrfHeaderName] = xsrfValue;\n\t    }\n\t  }\n\n\t  // Add headers to the request\n\t  if ('setRequestHeader' in request) {\n\t    utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n\t      if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n\t        // Remove Content-Type if data is undefined\n\t        delete requestHeaders[key];\n\t      } else {\n\t        // Otherwise add header to the request\n\t        request.setRequestHeader(key, val);\n\t      }\n\t    });\n\t  }\n\n\t  // Add withCredentials to request if needed\n\t  if (config.withCredentials) {\n\t    request.withCredentials = true;\n\t  }\n\n\t  // Add responseType to request if needed\n\t  if (config.responseType) {\n\t    try {\n\t      request.responseType = config.responseType;\n\t    } catch (e) {\n\t      if (request.responseType !== 'json') {\n\t        throw e;\n\t      }\n\t    }\n\t  }\n\n\t  if (utils.isArrayBuffer(requestData)) {\n\t    requestData = new DataView(requestData);\n\t  }\n\n\t  // Send the request\n\t  request.send(requestData);\n\t};\n\n\n/***/ },\n/* 8 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar utils = __webpack_require__(4);\n\n\tfunction encode(val) {\n\t  return encodeURIComponent(val).\n\t    replace(/%40/gi, '@').\n\t    replace(/%3A/gi, ':').\n\t    replace(/%24/g, '$').\n\t    replace(/%2C/gi, ',').\n\t    replace(/%20/g, '+').\n\t    replace(/%5B/gi, '[').\n\t    replace(/%5D/gi, ']');\n\t}\n\n\t/**\n\t * Build a URL by appending params to the end\n\t *\n\t * @param {string} url The base of the url (e.g., http://www.google.com)\n\t * @param {object} [params] The params to be appended\n\t * @returns {string} The formatted url\n\t */\n\tmodule.exports = function buildURL(url, params, paramsSerializer) {\n\t  /*eslint no-param-reassign:0*/\n\t  if (!params) {\n\t    return url;\n\t  }\n\n\t  var serializedParams;\n\t  if (paramsSerializer) {\n\t    serializedParams = paramsSerializer(params);\n\t  } else {\n\t    var parts = [];\n\n\t    utils.forEach(params, function serialize(val, key) {\n\t      if (val === null || typeof val === 'undefined') {\n\t        return;\n\t      }\n\n\t      if (utils.isArray(val)) {\n\t        key = key + '[]';\n\t      }\n\n\t      if (!utils.isArray(val)) {\n\t        val = [val];\n\t      }\n\n\t      utils.forEach(val, function parseValue(v) {\n\t        if (utils.isDate(v)) {\n\t          v = v.toISOString();\n\t        } else if (utils.isObject(v)) {\n\t          v = JSON.stringify(v);\n\t        }\n\t        parts.push(encode(key) + '=' + encode(v));\n\t      });\n\t    });\n\n\t    serializedParams = parts.join('&');\n\t  }\n\n\t  if (serializedParams) {\n\t    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n\t  }\n\n\t  return url;\n\t};\n\n\n\n/***/ },\n/* 9 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar utils = __webpack_require__(4);\n\n\t/**\n\t * Parse headers into an object\n\t *\n\t * ```\n\t * Date: Wed, 27 Aug 2014 08:58:49 GMT\n\t * Content-Type: application/json\n\t * Connection: keep-alive\n\t * Transfer-Encoding: chunked\n\t * ```\n\t *\n\t * @param {String} headers Headers needing to be parsed\n\t * @returns {Object} Headers parsed into an object\n\t */\n\tmodule.exports = function parseHeaders(headers) {\n\t  var parsed = {};\n\t  var key;\n\t  var val;\n\t  var i;\n\n\t  if (!headers) { return parsed; }\n\n\t  utils.forEach(headers.split('\\n'), function parser(line) {\n\t    i = line.indexOf(':');\n\t    key = utils.trim(line.substr(0, i)).toLowerCase();\n\t    val = utils.trim(line.substr(i + 1));\n\n\t    if (key) {\n\t      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n\t    }\n\t  });\n\n\t  return parsed;\n\t};\n\n\n/***/ },\n/* 10 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar utils = __webpack_require__(4);\n\n\t/**\n\t * Transform the data for a request or a response\n\t *\n\t * @param {Object|String} data The data to be transformed\n\t * @param {Array} headers The headers for the request or response\n\t * @param {Array|Function} fns A single function or Array of functions\n\t * @returns {*} The resulting transformed data\n\t */\n\tmodule.exports = function transformData(data, headers, fns) {\n\t  /*eslint no-param-reassign:0*/\n\t  utils.forEach(fns, function transform(fn) {\n\t    data = fn(data, headers);\n\t  });\n\n\t  return data;\n\t};\n\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar utils = __webpack_require__(4);\n\n\tmodule.exports = (\n\t  utils.isStandardBrowserEnv() ?\n\n\t  // Standard browser envs have full support of the APIs needed to test\n\t  // whether the request URL is of the same origin as current location.\n\t  (function standardBrowserEnv() {\n\t    var msie = /(msie|trident)/i.test(navigator.userAgent);\n\t    var urlParsingNode = document.createElement('a');\n\t    var originURL;\n\n\t    /**\n\t    * Parse a URL to discover it's components\n\t    *\n\t    * @param {String} url The URL to be parsed\n\t    * @returns {Object}\n\t    */\n\t    function resolveURL(url) {\n\t      var href = url;\n\n\t      if (msie) {\n\t        // IE needs attribute set twice to normalize properties\n\t        urlParsingNode.setAttribute('href', href);\n\t        href = urlParsingNode.href;\n\t      }\n\n\t      urlParsingNode.setAttribute('href', href);\n\n\t      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n\t      return {\n\t        href: urlParsingNode.href,\n\t        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n\t        host: urlParsingNode.host,\n\t        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n\t        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n\t        hostname: urlParsingNode.hostname,\n\t        port: urlParsingNode.port,\n\t        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n\t                  urlParsingNode.pathname :\n\t                  '/' + urlParsingNode.pathname\n\t      };\n\t    }\n\n\t    originURL = resolveURL(window.location.href);\n\n\t    /**\n\t    * Determine if a URL shares the same origin as the current location\n\t    *\n\t    * @param {String} requestURL The URL to test\n\t    * @returns {boolean} True if URL shares the same origin, otherwise false\n\t    */\n\t    return function isURLSameOrigin(requestURL) {\n\t      var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n\t      return (parsed.protocol === originURL.protocol &&\n\t            parsed.host === originURL.host);\n\t    };\n\t  })() :\n\n\t  // Non standard browser envs (web workers, react-native) lack needed support.\n\t  (function nonStandardBrowserEnv() {\n\t    return function isURLSameOrigin() {\n\t      return true;\n\t    };\n\t  })()\n\t);\n\n\n/***/ },\n/* 12 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\n\t// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js\n\n\tvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\n\tfunction InvalidCharacterError(message) {\n\t  this.message = message;\n\t}\n\tInvalidCharacterError.prototype = new Error;\n\tInvalidCharacterError.prototype.code = 5;\n\tInvalidCharacterError.prototype.name = 'InvalidCharacterError';\n\n\tfunction btoa(input) {\n\t  var str = String(input);\n\t  var output = '';\n\t  for (\n\t    // initialize result and counter\n\t    var block, charCode, idx = 0, map = chars;\n\t    // if the next str index does not exist:\n\t    //   change the mapping table to \"=\"\n\t    //   check if d has no fractional digits\n\t    str.charAt(idx | 0) || (map = '=', idx % 1);\n\t    // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n\t    output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n\t  ) {\n\t    charCode = str.charCodeAt(idx += 3 / 4);\n\t    if (charCode > 0xFF) {\n\t      throw new InvalidCharacterError('INVALID_CHARACTER_ERR: DOM Exception 5');\n\t    }\n\t    block = block << 8 | charCode;\n\t  }\n\t  return output;\n\t}\n\n\tmodule.exports = btoa;\n\n\n/***/ },\n/* 13 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar utils = __webpack_require__(4);\n\n\tmodule.exports = (\n\t  utils.isStandardBrowserEnv() ?\n\n\t  // Standard browser envs support document.cookie\n\t  (function standardBrowserEnv() {\n\t    return {\n\t      write: function write(name, value, expires, path, domain, secure) {\n\t        var cookie = [];\n\t        cookie.push(name + '=' + encodeURIComponent(value));\n\n\t        if (utils.isNumber(expires)) {\n\t          cookie.push('expires=' + new Date(expires).toGMTString());\n\t        }\n\n\t        if (utils.isString(path)) {\n\t          cookie.push('path=' + path);\n\t        }\n\n\t        if (utils.isString(domain)) {\n\t          cookie.push('domain=' + domain);\n\t        }\n\n\t        if (secure === true) {\n\t          cookie.push('secure');\n\t        }\n\n\t        document.cookie = cookie.join('; ');\n\t      },\n\n\t      read: function read(name) {\n\t        var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n\t        return (match ? decodeURIComponent(match[3]) : null);\n\t      },\n\n\t      remove: function remove(name) {\n\t        this.write(name, '', Date.now() - 86400000);\n\t      }\n\t    };\n\t  })() :\n\n\t  // Non standard browser env (web workers, react-native) lack needed support.\n\t  (function nonStandardBrowserEnv() {\n\t    return {\n\t      write: function write() {},\n\t      read: function read() { return null; },\n\t      remove: function remove() {}\n\t    };\n\t  })()\n\t);\n\n\n/***/ },\n/* 14 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar utils = __webpack_require__(4);\n\n\tfunction InterceptorManager() {\n\t  this.handlers = [];\n\t}\n\n\t/**\n\t * Add a new interceptor to the stack\n\t *\n\t * @param {Function} fulfilled The function to handle `then` for a `Promise`\n\t * @param {Function} rejected The function to handle `reject` for a `Promise`\n\t *\n\t * @return {Number} An ID used to remove interceptor later\n\t */\n\tInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n\t  this.handlers.push({\n\t    fulfilled: fulfilled,\n\t    rejected: rejected\n\t  });\n\t  return this.handlers.length - 1;\n\t};\n\n\t/**\n\t * Remove an interceptor from the stack\n\t *\n\t * @param {Number} id The ID that was returned by `use`\n\t */\n\tInterceptorManager.prototype.eject = function eject(id) {\n\t  if (this.handlers[id]) {\n\t    this.handlers[id] = null;\n\t  }\n\t};\n\n\t/**\n\t * Iterate over all the registered interceptors\n\t *\n\t * This method is particularly useful for skipping over any\n\t * interceptors that may have become `null` calling `eject`.\n\t *\n\t * @param {Function} fn The function to call for each interceptor\n\t */\n\tInterceptorManager.prototype.forEach = function forEach(fn) {\n\t  utils.forEach(this.handlers, function forEachHandler(h) {\n\t    if (h !== null) {\n\t      fn(h);\n\t    }\n\t  });\n\t};\n\n\tmodule.exports = InterceptorManager;\n\n\n/***/ },\n/* 15 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\n\t/**\n\t * Determines whether the specified URL is absolute\n\t *\n\t * @param {string} url The URL to test\n\t * @returns {boolean} True if the specified URL is absolute, otherwise false\n\t */\n\tmodule.exports = function isAbsoluteURL(url) {\n\t  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n\t  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n\t  // by any combination of letters, digits, plus, period, or hyphen.\n\t  return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n\t};\n\n\n/***/ },\n/* 16 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\n\t/**\n\t * Creates a new URL by combining the specified URLs\n\t *\n\t * @param {string} baseURL The base URL\n\t * @param {string} relativeURL The relative URL\n\t * @returns {string} The combined URL\n\t */\n\tmodule.exports = function combineURLs(baseURL, relativeURL) {\n\t  return baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '');\n\t};\n\n\n/***/ },\n/* 17 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\n\tmodule.exports = function bind(fn, thisArg) {\n\t  return function wrap() {\n\t    var args = new Array(arguments.length);\n\t    for (var i = 0; i < args.length; i++) {\n\t      args[i] = arguments[i];\n\t    }\n\t    return fn.apply(thisArg, args);\n\t  };\n\t};\n\n\n/***/ },\n/* 18 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\n\t/**\n\t * Syntactic sugar for invoking a function and expanding an array for arguments.\n\t *\n\t * Common use case would be to use `Function.prototype.apply`.\n\t *\n\t *  ```js\n\t *  function f(x, y, z) {}\n\t *  var args = [1, 2, 3];\n\t *  f.apply(null, args);\n\t *  ```\n\t *\n\t * With `spread` this example can be re-written.\n\t *\n\t *  ```js\n\t *  spread(function(x, y, z) {})([1, 2, 3]);\n\t *  ```\n\t *\n\t * @param {Function} callback\n\t * @returns {Function}\n\t */\n\tmodule.exports = function spread(callback) {\n\t  return function wrap(arr) {\n\t    return callback.apply(null, arr);\n\t  };\n\t};\n\n\n/***/ }\n/******/ ]);"]} | |
| var XeniaDriver = require('xenia-driver') | |
| // Configure your instance | |
| var xenia = XeniaDriver('https://demo.coralproject.net/xenia_api/1.0', 'Basic NmQ3MmU2ZGQtOTNkMC00NDEzLTliNGMtODU0NmQ0ZDM1MTRlOlBDeVgvTFRHWjhOdGZWOGVReXZObkpydm4xc2loQk9uQW5TNFpGZGNFdnc9') | |
| // Use the driver | |
| xenia() | |
| .collection('comments') | |
| .include(['body', 'asset_id']) | |
| .limit(5) | |
| .join('assets', '_id', 'asset_id', 'asset') | |
| .include(['section']) | |
| .exec().then(data => document.write(JSON.stringify(data.results, null, '\t'))) | |
| ;}, 0) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "name": "requirebin-sketch", | |
| "version": "1.0.0", | |
| "dependencies": { | |
| "xenia-driver": "0.0.2" | |
| } | |
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <body> --> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!-- contents of this file will be placed inside the <head> --> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment