Skip to content

Instantly share code, notes, and snippets.

@impronunciable impronunciable/index.js
Last active Apr 18, 2016

Embed
What would you like to do?
requirebin sketch
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')))
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)
{
"name": "requirebin-sketch",
"version": "1.0.0",
"dependencies": {
"xenia-driver": "0.0.2"
}
}
<!-- contents of this file will be placed inside the <body> -->
<!-- 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
You can’t perform that action at this time.