text: /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  
  
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/// <reference path="./all.d.ts" />
  	"use strict";
  	var core_1 = __webpack_require__(1);
  	__webpack_require__(37);
  	__webpack_require__(38);
  	__webpack_require__(39);
  	__webpack_require__(40);
  	__webpack_require__(41);
  	__webpack_require__(42);
  	__webpack_require__(43);
  	__webpack_require__(45);
  	if (!window['searchandiser']) {
  	    window['searchandiser'] = core_1.Searchandiser;
  	}
  
  
  /***/ },
  /* 1 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var groupby_api_1 = __webpack_require__(2);
  	var riot = __webpack_require__(35);
  	var Searchandiser = (function () {
  	    function Searchandiser(config) {
  	        if (config === void 0) { config = {}; }
  	        Searchandiser.CONFIG = config;
  	        Searchandiser.bridge = new groupby_api_1.BrowserBridge(config.customerId);
  	        riot.observable(Searchandiser.el);
  	    }
  	    Searchandiser.attach = function (tagName, cssSelector, options, handler) {
  	        if (options === void 0) { options = {}; }
  	        riot.mount(cssSelector, "gb-" + tagName, Object.assign({ stylish: Searchandiser.CONFIG.stylish }, options, { srch: Searchandiser }));
  	    };
  	    Searchandiser.search = function (query) {
  	        var queryObj = typeof query === 'string' ? new groupby_api_1.Query(query) : query;
  	        queryObj.withConfiguration({
  	            collection: Searchandiser.CONFIG.collection,
  	            area: Searchandiser.CONFIG.area,
  	            language: Searchandiser.CONFIG.language
  	        });
  	        this.bridge.search(queryObj, function (err, res) {
  	            Searchandiser.query = queryObj;
  	            Searchandiser.results = res;
  	            Searchandiser.el.trigger('results');
  	            console.log(res);
  	        });
  	    };
  	    Searchandiser.CONFIG = {};
  	    Searchandiser.state = {
  	        lastStep: 0,
  	        refinements: []
  	    };
  	    Searchandiser.el = {};
  	    return Searchandiser;
  	}());
  	exports.Searchandiser = Searchandiser;
  
  
  /***/ },
  /* 2 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(3);
  
  
  /***/ },
  /* 3 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {/// <reference path="./all.d.ts" />
  	"use strict";
  	function __export(m) {
  	    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
  	}
  	if (!global.Promise) {
  	    __webpack_require__(4).polyfill();
  	}
  	__export(__webpack_require__(9));
  	__export(__webpack_require__(17));
  	__export(__webpack_require__(15));
  	__export(__webpack_require__(16));
  
  	//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImFwaS1qYXZhc2NyaXB0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG1DQUFtQzs7Ozs7QUFFbkMsRUFBRSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUNwQixPQUFPLENBQUMsYUFBYSxDQUFDLENBQUMsUUFBUSxFQUFFLENBQUM7QUFDcEMsQ0FBQztBQUNELGlCQUFjLGNBQWMsQ0FBQyxFQUFBO0FBQzdCLGlCQUFjLGVBQWUsQ0FBQyxFQUFBO0FBQzlCLGlCQUFjLGtCQUFrQixDQUFDLEVBQUE7QUFFakMsaUJBQWMsUUFBUSxDQUFDLEVBQUEiLCJmaWxlIjoiYXBpLWphdmFzY3JpcHQuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLy8gPHJlZmVyZW5jZSBwYXRoPVwiLi9hbGwuZC50c1wiIC8+XG5cbmlmICghZ2xvYmFsLlByb21pc2UpIHtcbiAgcmVxdWlyZSgnZXM2LXByb21pc2UnKS5wb2x5ZmlsbCgpO1xufVxuZXhwb3J0ICogZnJvbSAnLi9jb3JlL3F1ZXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vY29yZS9icmlkZ2UnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXF1ZXN0LW1vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc3BvbnNlLW1vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWwnO1xuIl0sInNvdXJjZVJvb3QiOiIvc291cmNlLyJ9
  
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 4 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var require;var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(process, global, module) {/*!
  	 * @overview es6-promise - a tiny implementation of Promises/A+.
  	 * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
  	 * @license   Licensed under MIT license
  	 *            See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE
  	 * @version   3.2.1
  	 */
  
  	(function() {
  	    "use strict";
  	    function lib$es6$promise$utils$$objectOrFunction(x) {
  	      return typeof x === 'function' || (typeof x === 'object' && x !== null);
  	    }
  
  	    function lib$es6$promise$utils$$isFunction(x) {
  	      return typeof x === 'function';
  	    }
  
  	    function lib$es6$promise$utils$$isMaybeThenable(x) {
  	      return typeof x === 'object' && x !== null;
  	    }
  
  	    var lib$es6$promise$utils$$_isArray;
  	    if (!Array.isArray) {
  	      lib$es6$promise$utils$$_isArray = function (x) {
  	        return Object.prototype.toString.call(x) === '[object Array]';
  	      };
  	    } else {
  	      lib$es6$promise$utils$$_isArray = Array.isArray;
  	    }
  
  	    var lib$es6$promise$utils$$isArray = lib$es6$promise$utils$$_isArray;
  	    var lib$es6$promise$asap$$len = 0;
  	    var lib$es6$promise$asap$$vertxNext;
  	    var lib$es6$promise$asap$$customSchedulerFn;
  
  	    var lib$es6$promise$asap$$asap = function asap(callback, arg) {
  	      lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len] = callback;
  	      lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len + 1] = arg;
  	      lib$es6$promise$asap$$len += 2;
  	      if (lib$es6$promise$asap$$len === 2) {
  	        // If len is 2, that means that we need to schedule an async flush.
  	        // If additional callbacks are queued before the queue is flushed, they
  	        // will be processed by this flush that we are scheduling.
  	        if (lib$es6$promise$asap$$customSchedulerFn) {
  	          lib$es6$promise$asap$$customSchedulerFn(lib$es6$promise$asap$$flush);
  	        } else {
  	          lib$es6$promise$asap$$scheduleFlush();
  	        }
  	      }
  	    }
  
  	    function lib$es6$promise$asap$$setScheduler(scheduleFn) {
  	      lib$es6$promise$asap$$customSchedulerFn = scheduleFn;
  	    }
  
  	    function lib$es6$promise$asap$$setAsap(asapFn) {
  	      lib$es6$promise$asap$$asap = asapFn;
  	    }
  
  	    var lib$es6$promise$asap$$browserWindow = (typeof window !== 'undefined') ? window : undefined;
  	    var lib$es6$promise$asap$$browserGlobal = lib$es6$promise$asap$$browserWindow || {};
  	    var lib$es6$promise$asap$$BrowserMutationObserver = lib$es6$promise$asap$$browserGlobal.MutationObserver || lib$es6$promise$asap$$browserGlobal.WebKitMutationObserver;
  	    var lib$es6$promise$asap$$isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
  
  	    // test for web worker but not in IE10
  	    var lib$es6$promise$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&
  	      typeof importScripts !== 'undefined' &&
  	      typeof MessageChannel !== 'undefined';
  
  	    // node
  	    function lib$es6$promise$asap$$useNextTick() {
  	      // node version 0.10.x displays a deprecation warning when nextTick is used recursively
  	      // see https://github.com/cujojs/when/issues/410 for details
  	      return function() {
  	        process.nextTick(lib$es6$promise$asap$$flush);
  	      };
  	    }
  
  	    // vertx
  	    function lib$es6$promise$asap$$useVertxTimer() {
  	      return function() {
  	        lib$es6$promise$asap$$vertxNext(lib$es6$promise$asap$$flush);
  	      };
  	    }
  
  	    function lib$es6$promise$asap$$useMutationObserver() {
  	      var iterations = 0;
  	      var observer = new lib$es6$promise$asap$$BrowserMutationObserver(lib$es6$promise$asap$$flush);
  	      var node = document.createTextNode('');
  	      observer.observe(node, { characterData: true });
  
  	      return function() {
  	        node.data = (iterations = ++iterations % 2);
  	      };
  	    }
  
  	    // web worker
  	    function lib$es6$promise$asap$$useMessageChannel() {
  	      var channel = new MessageChannel();
  	      channel.port1.onmessage = lib$es6$promise$asap$$flush;
  	      return function () {
  	        channel.port2.postMessage(0);
  	      };
  	    }
  
  	    function lib$es6$promise$asap$$useSetTimeout() {
  	      return function() {
  	        setTimeout(lib$es6$promise$asap$$flush, 1);
  	      };
  	    }
  
  	    var lib$es6$promise$asap$$queue = new Array(1000);
  	    function lib$es6$promise$asap$$flush() {
  	      for (var i = 0; i < lib$es6$promise$asap$$len; i+=2) {
  	        var callback = lib$es6$promise$asap$$queue[i];
  	        var arg = lib$es6$promise$asap$$queue[i+1];
  
  	        callback(arg);
  
  	        lib$es6$promise$asap$$queue[i] = undefined;
  	        lib$es6$promise$asap$$queue[i+1] = undefined;
  	      }
  
  	      lib$es6$promise$asap$$len = 0;
  	    }
  
  	    function lib$es6$promise$asap$$attemptVertx() {
  	      try {
  	        var r = require;
  	        var vertx = __webpack_require__(7);
  	        lib$es6$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext;
  	        return lib$es6$promise$asap$$useVertxTimer();
  	      } catch(e) {
  	        return lib$es6$promise$asap$$useSetTimeout();
  	      }
  	    }
  
  	    var lib$es6$promise$asap$$scheduleFlush;
  	    // Decide what async method to use to triggering processing of queued callbacks:
  	    if (lib$es6$promise$asap$$isNode) {
  	      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useNextTick();
  	    } else if (lib$es6$promise$asap$$BrowserMutationObserver) {
  	      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMutationObserver();
  	    } else if (lib$es6$promise$asap$$isWorker) {
  	      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMessageChannel();
  	    } else if (lib$es6$promise$asap$$browserWindow === undefined && "function" === 'function') {
  	      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$attemptVertx();
  	    } else {
  	      lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useSetTimeout();
  	    }
  	    function lib$es6$promise$then$$then(onFulfillment, onRejection) {
  	      var parent = this;
  
  	      var child = new this.constructor(lib$es6$promise$$internal$$noop);
  
  	      if (child[lib$es6$promise$$internal$$PROMISE_ID] === undefined) {
  	        lib$es6$promise$$internal$$makePromise(child);
  	      }
  
  	      var state = parent._state;
  
  	      if (state) {
  	        var callback = arguments[state - 1];
  	        lib$es6$promise$asap$$asap(function(){
  	          lib$es6$promise$$internal$$invokeCallback(state, child, callback, parent._result);
  	        });
  	      } else {
  	        lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection);
  	      }
  
  	      return child;
  	    }
  	    var lib$es6$promise$then$$default = lib$es6$promise$then$$then;
  	    function lib$es6$promise$promise$resolve$$resolve(object) {
  	      /*jshint validthis:true */
  	      var Constructor = this;
  
  	      if (object && typeof object === 'object' && object.constructor === Constructor) {
  	        return object;
  	      }
  
  	      var promise = new Constructor(lib$es6$promise$$internal$$noop);
  	      lib$es6$promise$$internal$$resolve(promise, object);
  	      return promise;
  	    }
  	    var lib$es6$promise$promise$resolve$$default = lib$es6$promise$promise$resolve$$resolve;
  	    var lib$es6$promise$$internal$$PROMISE_ID = Math.random().toString(36).substring(16);
  
  	    function lib$es6$promise$$internal$$noop() {}
  
  	    var lib$es6$promise$$internal$$PENDING   = void 0;
  	    var lib$es6$promise$$internal$$FULFILLED = 1;
  	    var lib$es6$promise$$internal$$REJECTED  = 2;
  
  	    var lib$es6$promise$$internal$$GET_THEN_ERROR = new lib$es6$promise$$internal$$ErrorObject();
  
  	    function lib$es6$promise$$internal$$selfFulfillment() {
  	      return new TypeError("You cannot resolve a promise with itself");
  	    }
  
  	    function lib$es6$promise$$internal$$cannotReturnOwn() {
  	      return new TypeError('A promises callback cannot return that same promise.');
  	    }
  
  	    function lib$es6$promise$$internal$$getThen(promise) {
  	      try {
  	        return promise.then;
  	      } catch(error) {
  	        lib$es6$promise$$internal$$GET_THEN_ERROR.error = error;
  	        return lib$es6$promise$$internal$$GET_THEN_ERROR;
  	      }
  	    }
  
  	    function lib$es6$promise$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) {
  	      try {
  	        then.call(value, fulfillmentHandler, rejectionHandler);
  	      } catch(e) {
  	        return e;
  	      }
  	    }
  
  	    function lib$es6$promise$$internal$$handleForeignThenable(promise, thenable, then) {
  	       lib$es6$promise$asap$$asap(function(promise) {
  	        var sealed = false;
  	        var error = lib$es6$promise$$internal$$tryThen(then, thenable, function(value) {
  	          if (sealed) { return; }
  	          sealed = true;
  	          if (thenable !== value) {
  	            lib$es6$promise$$internal$$resolve(promise, value);
  	          } else {
  	            lib$es6$promise$$internal$$fulfill(promise, value);
  	          }
  	        }, function(reason) {
  	          if (sealed) { return; }
  	          sealed = true;
  
  	          lib$es6$promise$$internal$$reject(promise, reason);
  	        }, 'Settle: ' + (promise._label || ' unknown promise'));
  
  	        if (!sealed && error) {
  	          sealed = true;
  	          lib$es6$promise$$internal$$reject(promise, error);
  	        }
  	      }, promise);
  	    }
  
  	    function lib$es6$promise$$internal$$handleOwnThenable(promise, thenable) {
  	      if (thenable._state === lib$es6$promise$$internal$$FULFILLED) {
  	        lib$es6$promise$$internal$$fulfill(promise, thenable._result);
  	      } else if (thenable._state === lib$es6$promise$$internal$$REJECTED) {
  	        lib$es6$promise$$internal$$reject(promise, thenable._result);
  	      } else {
  	        lib$es6$promise$$internal$$subscribe(thenable, undefined, function(value) {
  	          lib$es6$promise$$internal$$resolve(promise, value);
  	        }, function(reason) {
  	          lib$es6$promise$$internal$$reject(promise, reason);
  	        });
  	      }
  	    }
  
  	    function lib$es6$promise$$internal$$handleMaybeThenable(promise, maybeThenable, then) {
  	      if (maybeThenable.constructor === promise.constructor &&
  	          then === lib$es6$promise$then$$default &&
  	          constructor.resolve === lib$es6$promise$promise$resolve$$default) {
  	        lib$es6$promise$$internal$$handleOwnThenable(promise, maybeThenable);
  	      } else {
  	        if (then === lib$es6$promise$$internal$$GET_THEN_ERROR) {
  	          lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$GET_THEN_ERROR.error);
  	        } else if (then === undefined) {
  	          lib$es6$promise$$internal$$fulfill(promise, maybeThenable);
  	        } else if (lib$es6$promise$utils$$isFunction(then)) {
  	          lib$es6$promise$$internal$$handleForeignThenable(promise, maybeThenable, then);
  	        } else {
  	          lib$es6$promise$$internal$$fulfill(promise, maybeThenable);
  	        }
  	      }
  	    }
  
  	    function lib$es6$promise$$internal$$resolve(promise, value) {
  	      if (promise === value) {
  	        lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$selfFulfillment());
  	      } else if (lib$es6$promise$utils$$objectOrFunction(value)) {
  	        lib$es6$promise$$internal$$handleMaybeThenable(promise, value, lib$es6$promise$$internal$$getThen(value));
  	      } else {
  	        lib$es6$promise$$internal$$fulfill(promise, value);
  	      }
  	    }
  
  	    function lib$es6$promise$$internal$$publishRejection(promise) {
  	      if (promise._onerror) {
  	        promise._onerror(promise._result);
  	      }
  
  	      lib$es6$promise$$internal$$publish(promise);
  	    }
  
  	    function lib$es6$promise$$internal$$fulfill(promise, value) {
  	      if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }
  
  	      promise._result = value;
  	      promise._state = lib$es6$promise$$internal$$FULFILLED;
  
  	      if (promise._subscribers.length !== 0) {
  	        lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, promise);
  	      }
  	    }
  
  	    function lib$es6$promise$$internal$$reject(promise, reason) {
  	      if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }
  	      promise._state = lib$es6$promise$$internal$$REJECTED;
  	      promise._result = reason;
  
  	      lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publishRejection, promise);
  	    }
  
  	    function lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection) {
  	      var subscribers = parent._subscribers;
  	      var length = subscribers.length;
  
  	      parent._onerror = null;
  
  	      subscribers[length] = child;
  	      subscribers[length + lib$es6$promise$$internal$$FULFILLED] = onFulfillment;
  	      subscribers[length + lib$es6$promise$$internal$$REJECTED]  = onRejection;
  
  	      if (length === 0 && parent._state) {
  	        lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, parent);
  	      }
  	    }
  
  	    function lib$es6$promise$$internal$$publish(promise) {
  	      var subscribers = promise._subscribers;
  	      var settled = promise._state;
  
  	      if (subscribers.length === 0) { return; }
  
  	      var child, callback, detail = promise._result;
  
  	      for (var i = 0; i < subscribers.length; i += 3) {
  	        child = subscribers[i];
  	        callback = subscribers[i + settled];
  
  	        if (child) {
  	          lib$es6$promise$$internal$$invokeCallback(settled, child, callback, detail);
  	        } else {
  	          callback(detail);
  	        }
  	      }
  
  	      promise._subscribers.length = 0;
  	    }
  
  	    function lib$es6$promise$$internal$$ErrorObject() {
  	      this.error = null;
  	    }
  
  	    var lib$es6$promise$$internal$$TRY_CATCH_ERROR = new lib$es6$promise$$internal$$ErrorObject();
  
  	    function lib$es6$promise$$internal$$tryCatch(callback, detail) {
  	      try {
  	        return callback(detail);
  	      } catch(e) {
  	        lib$es6$promise$$internal$$TRY_CATCH_ERROR.error = e;
  	        return lib$es6$promise$$internal$$TRY_CATCH_ERROR;
  	      }
  	    }
  
  	    function lib$es6$promise$$internal$$invokeCallback(settled, promise, callback, detail) {
  	      var hasCallback = lib$es6$promise$utils$$isFunction(callback),
  	          value, error, succeeded, failed;
  
  	      if (hasCallback) {
  	        value = lib$es6$promise$$internal$$tryCatch(callback, detail);
  
  	        if (value === lib$es6$promise$$internal$$TRY_CATCH_ERROR) {
  	          failed = true;
  	          error = value.error;
  	          value = null;
  	        } else {
  	          succeeded = true;
  	        }
  
  	        if (promise === value) {
  	          lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$cannotReturnOwn());
  	          return;
  	        }
  
  	      } else {
  	        value = detail;
  	        succeeded = true;
  	      }
  
  	      if (promise._state !== lib$es6$promise$$internal$$PENDING) {
  	        // noop
  	      } else if (hasCallback && succeeded) {
  	        lib$es6$promise$$internal$$resolve(promise, value);
  	      } else if (failed) {
  	        lib$es6$promise$$internal$$reject(promise, error);
  	      } else if (settled === lib$es6$promise$$internal$$FULFILLED) {
  	        lib$es6$promise$$internal$$fulfill(promise, value);
  	      } else if (settled === lib$es6$promise$$internal$$REJECTED) {
  	        lib$es6$promise$$internal$$reject(promise, value);
  	      }
  	    }
  
  	    function lib$es6$promise$$internal$$initializePromise(promise, resolver) {
  	      try {
  	        resolver(function resolvePromise(value){
  	          lib$es6$promise$$internal$$resolve(promise, value);
  	        }, function rejectPromise(reason) {
  	          lib$es6$promise$$internal$$reject(promise, reason);
  	        });
  	      } catch(e) {
  	        lib$es6$promise$$internal$$reject(promise, e);
  	      }
  	    }
  
  	    var lib$es6$promise$$internal$$id = 0;
  	    function lib$es6$promise$$internal$$nextId() {
  	      return lib$es6$promise$$internal$$id++;
  	    }
  
  	    function lib$es6$promise$$internal$$makePromise(promise) {
  	      promise[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$id++;
  	      promise._state = undefined;
  	      promise._result = undefined;
  	      promise._subscribers = [];
  	    }
  
  	    function lib$es6$promise$promise$all$$all(entries) {
  	      return new lib$es6$promise$enumerator$$default(this, entries).promise;
  	    }
  	    var lib$es6$promise$promise$all$$default = lib$es6$promise$promise$all$$all;
  	    function lib$es6$promise$promise$race$$race(entries) {
  	      /*jshint validthis:true */
  	      var Constructor = this;
  
  	      if (!lib$es6$promise$utils$$isArray(entries)) {
  	        return new Constructor(function(resolve, reject) {
  	          reject(new TypeError('You must pass an array to race.'));
  	        });
  	      } else {
  	        return new Constructor(function(resolve, reject) {
  	          var length = entries.length;
  	          for (var i = 0; i < length; i++) {
  	            Constructor.resolve(entries[i]).then(resolve, reject);
  	          }
  	        });
  	      }
  	    }
  	    var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race;
  	    function lib$es6$promise$promise$reject$$reject(reason) {
  	      /*jshint validthis:true */
  	      var Constructor = this;
  	      var promise = new Constructor(lib$es6$promise$$internal$$noop);
  	      lib$es6$promise$$internal$$reject(promise, reason);
  	      return promise;
  	    }
  	    var lib$es6$promise$promise$reject$$default = lib$es6$promise$promise$reject$$reject;
  
  
  	    function lib$es6$promise$promise$$needsResolver() {
  	      throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
  	    }
  
  	    function lib$es6$promise$promise$$needsNew() {
  	      throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
  	    }
  
  	    var lib$es6$promise$promise$$default = lib$es6$promise$promise$$Promise;
  	    /**
  	      Promise objects represent the eventual result of an asynchronous operation. The
  	      primary way of interacting with a promise is through its `then` method, which
  	      registers callbacks to receive either a promise's eventual value or the reason
  	      why the promise cannot be fulfilled.
  
  	      Terminology
  	      -----------
  
  	      - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
  	      - `thenable` is an object or function that defines a `then` method.
  	      - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
  	      - `exception` is a value that is thrown using the throw statement.
  	      - `reason` is a value that indicates why a promise was rejected.
  	      - `settled` the final resting state of a promise, fulfilled or rejected.
  
  	      A promise can be in one of three states: pending, fulfilled, or rejected.
  
  	      Promises that are fulfilled have a fulfillment value and are in the fulfilled
  	      state.  Promises that are rejected have a rejection reason and are in the
  	      rejected state.  A fulfillment value is never a thenable.
  
  	      Promises can also be said to *resolve* a value.  If this value is also a
  	      promise, then the original promise's settled state will match the value's
  	      settled state.  So a promise that *resolves* a promise that rejects will
  	      itself reject, and a promise that *resolves* a promise that fulfills will
  	      itself fulfill.
  
  
  	      Basic Usage:
  	      ------------
  
  	      ```js
  	      var promise = new Promise(function(resolve, reject) {
  	        // on success
  	        resolve(value);
  
  	        // on failure
  	        reject(reason);
  	      });
  
  	      promise.then(function(value) {
  	        // on fulfillment
  	      }, function(reason) {
  	        // on rejection
  	      });
  	      ```
  
  	      Advanced Usage:
  	      ---------------
  
  	      Promises shine when abstracting away asynchronous interactions such as
  	      `XMLHttpRequest`s.
  
  	      ```js
  	      function getJSON(url) {
  	        return new Promise(function(resolve, reject){
  	          var xhr = new XMLHttpRequest();
  
  	          xhr.open('GET', url);
  	          xhr.onreadystatechange = handler;
  	          xhr.responseType = 'json';
  	          xhr.setRequestHeader('Accept', 'application/json');
  	          xhr.send();
  
  	          function handler() {
  	            if (this.readyState === this.DONE) {
  	              if (this.status === 200) {
  	                resolve(this.response);
  	              } else {
  	                reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
  	              }
  	            }
  	          };
  	        });
  	      }
  
  	      getJSON('/posts.json').then(function(json) {
  	        // on fulfillment
  	      }, function(reason) {
  	        // on rejection
  	      });
  	      ```
  
  	      Unlike callbacks, promises are great composable primitives.
  
  	      ```js
  	      Promise.all([
  	        getJSON('/posts'),
  	        getJSON('/comments')
  	      ]).then(function(values){
  	        values[0] // => postsJSON
  	        values[1] // => commentsJSON
  
  	        return values;
  	      });
  	      ```
  
  	      @class Promise
  	      @param {function} resolver
  	      Useful for tooling.
  	      @constructor
  	    */
  	    function lib$es6$promise$promise$$Promise(resolver) {
  	      this[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$nextId();
  	      this._result = this._state = undefined;
  	      this._subscribers = [];
  
  	      if (lib$es6$promise$$internal$$noop !== resolver) {
  	        typeof resolver !== 'function' && lib$es6$promise$promise$$needsResolver();
  	        this instanceof lib$es6$promise$promise$$Promise ? lib$es6$promise$$internal$$initializePromise(this, resolver) : lib$es6$promise$promise$$needsNew();
  	      }
  	    }
  
  	    lib$es6$promise$promise$$Promise.all = lib$es6$promise$promise$all$$default;
  	    lib$es6$promise$promise$$Promise.race = lib$es6$promise$promise$race$$default;
  	    lib$es6$promise$promise$$Promise.resolve = lib$es6$promise$promise$resolve$$default;
  	    lib$es6$promise$promise$$Promise.reject = lib$es6$promise$promise$reject$$default;
  	    lib$es6$promise$promise$$Promise._setScheduler = lib$es6$promise$asap$$setScheduler;
  	    lib$es6$promise$promise$$Promise._setAsap = lib$es6$promise$asap$$setAsap;
  	    lib$es6$promise$promise$$Promise._asap = lib$es6$promise$asap$$asap;
  
  	    lib$es6$promise$promise$$Promise.prototype = {
  	      constructor: lib$es6$promise$promise$$Promise,
  
  	    /**
  	      The primary way of interacting with a promise is through its `then` method,
  	      which registers callbacks to receive either a promise's eventual value or the
  	      reason why the promise cannot be fulfilled.
  
  	      ```js
  	      findUser().then(function(user){
  	        // user is available
  	      }, function(reason){
  	        // user is unavailable, and you are given the reason why
  	      });
  	      ```
  
  	      Chaining
  	      --------
  
  	      The return value of `then` is itself a promise.  This second, 'downstream'
  	      promise is resolved with the return value of the first promise's fulfillment
  	      or rejection handler, or rejected if the handler throws an exception.
  
  	      ```js
  	      findUser().then(function (user) {
  	        return user.name;
  	      }, function (reason) {
  	        return 'default name';
  	      }).then(function (userName) {
  	        // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
  	        // will be `'default name'`
  	      });
  
  	      findUser().then(function (user) {
  	        throw new Error('Found user, but still unhappy');
  	      }, function (reason) {
  	        throw new Error('`findUser` rejected and we're unhappy');
  	      }).then(function (value) {
  	        // never reached
  	      }, function (reason) {
  	        // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
  	        // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
  	      });
  	      ```
  	      If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
  
  	      ```js
  	      findUser().then(function (user) {
  	        throw new PedagogicalException('Upstream error');
  	      }).then(function (value) {
  	        // never reached
  	      }).then(function (value) {
  	        // never reached
  	      }, function (reason) {
  	        // The `PedgagocialException` is propagated all the way down to here
  	      });
  	      ```
  
  	      Assimilation
  	      ------------
  
  	      Sometimes the value you want to propagate to a downstream promise can only be
  	      retrieved asynchronously. This can be achieved by returning a promise in the
  	      fulfillment or rejection handler. The downstream promise will then be pending
  	      until the returned promise is settled. This is called *assimilation*.
  
  	      ```js
  	      findUser().then(function (user) {
  	        return findCommentsByAuthor(user);
  	      }).then(function (comments) {
  	        // The user's comments are now available
  	      });
  	      ```
  
  	      If the assimliated promise rejects, then the downstream promise will also reject.
  
  	      ```js
  	      findUser().then(function (user) {
  	        return findCommentsByAuthor(user);
  	      }).then(function (comments) {
  	        // If `findCommentsByAuthor` fulfills, we'll have the value here
  	      }, function (reason) {
  	        // If `findCommentsByAuthor` rejects, we'll have the reason here
  	      });
  	      ```
  
  	      Simple Example
  	      --------------
  
  	      Synchronous Example
  
  	      ```javascript
  	      var result;
  
  	      try {
  	        result = findResult();
  	        // success
  	      } catch(reason) {
  	        // failure
  	      }
  	      ```
  
  	      Errback Example
  
  	      ```js
  	      findResult(function(result, err){
  	        if (err) {
  	          // failure
  	        } else {
  	          // success
  	        }
  	      });
  	      ```
  
  	      Promise Example;
  
  	      ```javascript
  	      findResult().then(function(result){
  	        // success
  	      }, function(reason){
  	        // failure
  	      });
  	      ```
  
  	      Advanced Example
  	      --------------
  
  	      Synchronous Example
  
  	      ```javascript
  	      var author, books;
  
  	      try {
  	        author = findAuthor();
  	        books  = findBooksByAuthor(author);
  	        // success
  	      } catch(reason) {
  	        // failure
  	      }
  	      ```
  
  	      Errback Example
  
  	      ```js
  
  	      function foundBooks(books) {
  
  	      }
  
  	      function failure(reason) {
  
  	      }
  
  	      findAuthor(function(author, err){
  	        if (err) {
  	          failure(err);
  	          // failure
  	        } else {
  	          try {
  	            findBoooksByAuthor(author, function(books, err) {
  	              if (err) {
  	                failure(err);
  	              } else {
  	                try {
  	                  foundBooks(books);
  	                } catch(reason) {
  	                  failure(reason);
  	                }
  	              }
  	            });
  	          } catch(error) {
  	            failure(err);
  	          }
  	          // success
  	        }
  	      });
  	      ```
  
  	      Promise Example;
  
  	      ```javascript
  	      findAuthor().
  	        then(findBooksByAuthor).
  	        then(function(books){
  	          // found books
  	      }).catch(function(reason){
  	        // something went wrong
  	      });
  	      ```
  
  	      @method then
  	      @param {Function} onFulfilled
  	      @param {Function} onRejected
  	      Useful for tooling.
  	      @return {Promise}
  	    */
  	      then: lib$es6$promise$then$$default,
  
  	    /**
  	      `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
  	      as the catch block of a try/catch statement.
  
  	      ```js
  	      function findAuthor(){
  	        throw new Error('couldn't find that author');
  	      }
  
  	      // synchronous
  	      try {
  	        findAuthor();
  	      } catch(reason) {
  	        // something went wrong
  	      }
  
  	      // async with promises
  	      findAuthor().catch(function(reason){
  	        // something went wrong
  	      });
  	      ```
  
  	      @method catch
  	      @param {Function} onRejection
  	      Useful for tooling.
  	      @return {Promise}
  	    */
  	      'catch': function(onRejection) {
  	        return this.then(null, onRejection);
  	      }
  	    };
  	    var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator;
  	    function lib$es6$promise$enumerator$$Enumerator(Constructor, input) {
  	      this._instanceConstructor = Constructor;
  	      this.promise = new Constructor(lib$es6$promise$$internal$$noop);
  
  	      if (!this.promise[lib$es6$promise$$internal$$PROMISE_ID]) {
  	        lib$es6$promise$$internal$$makePromise(this.promise);
  	      }
  
  	      if (lib$es6$promise$utils$$isArray(input)) {
  	        this._input     = input;
  	        this.length     = input.length;
  	        this._remaining = input.length;
  
  	        this._result = new Array(this.length);
  
  	        if (this.length === 0) {
  	          lib$es6$promise$$internal$$fulfill(this.promise, this._result);
  	        } else {
  	          this.length = this.length || 0;
  	          this._enumerate();
  	          if (this._remaining === 0) {
  	            lib$es6$promise$$internal$$fulfill(this.promise, this._result);
  	          }
  	        }
  	      } else {
  	        lib$es6$promise$$internal$$reject(this.promise, lib$es6$promise$enumerator$$validationError());
  	      }
  	    }
  
  	    function lib$es6$promise$enumerator$$validationError() {
  	      return new Error('Array Methods must be provided an Array');
  	    }
  
  	    lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() {
  	      var length  = this.length;
  	      var input   = this._input;
  
  	      for (var i = 0; this._state === lib$es6$promise$$internal$$PENDING && i < length; i++) {
  	        this._eachEntry(input[i], i);
  	      }
  	    };
  
  	    lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {
  	      var c = this._instanceConstructor;
  	      var resolve = c.resolve;
  
  	      if (resolve === lib$es6$promise$promise$resolve$$default) {
  	        var then = lib$es6$promise$$internal$$getThen(entry);
  
  	        if (then === lib$es6$promise$then$$default &&
  	            entry._state !== lib$es6$promise$$internal$$PENDING) {
  	          this._settledAt(entry._state, i, entry._result);
  	        } else if (typeof then !== 'function') {
  	          this._remaining--;
  	          this._result[i] = entry;
  	        } else if (c === lib$es6$promise$promise$$default) {
  	          var promise = new c(lib$es6$promise$$internal$$noop);
  	          lib$es6$promise$$internal$$handleMaybeThenable(promise, entry, then);
  	          this._willSettleAt(promise, i);
  	        } else {
  	          this._willSettleAt(new c(function(resolve) { resolve(entry); }), i);
  	        }
  	      } else {
  	        this._willSettleAt(resolve(entry), i);
  	      }
  	    };
  
  	    lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {
  	      var promise = this.promise;
  
  	      if (promise._state === lib$es6$promise$$internal$$PENDING) {
  	        this._remaining--;
  
  	        if (state === lib$es6$promise$$internal$$REJECTED) {
  	          lib$es6$promise$$internal$$reject(promise, value);
  	        } else {
  	          this._result[i] = value;
  	        }
  	      }
  
  	      if (this._remaining === 0) {
  	        lib$es6$promise$$internal$$fulfill(promise, this._result);
  	      }
  	    };
  
  	    lib$es6$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {
  	      var enumerator = this;
  
  	      lib$es6$promise$$internal$$subscribe(promise, undefined, function(value) {
  	        enumerator._settledAt(lib$es6$promise$$internal$$FULFILLED, i, value);
  	      }, function(reason) {
  	        enumerator._settledAt(lib$es6$promise$$internal$$REJECTED, i, reason);
  	      });
  	    };
  	    function lib$es6$promise$polyfill$$polyfill() {
  	      var local;
  
  	      if (typeof global !== 'undefined') {
  	          local = global;
  	      } else if (typeof self !== 'undefined') {
  	          local = self;
  	      } else {
  	          try {
  	              local = Function('return this')();
  	          } catch (e) {
  	              throw new Error('polyfill failed because global object is unavailable in this environment');
  	          }
  	      }
  
  	      var P = local.Promise;
  
  	      if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) {
  	        return;
  	      }
  
  	      local.Promise = lib$es6$promise$promise$$default;
  	    }
  	    var lib$es6$promise$polyfill$$default = lib$es6$promise$polyfill$$polyfill;
  
  	    var lib$es6$promise$umd$$ES6Promise = {
  	      'Promise': lib$es6$promise$promise$$default,
  	      'polyfill': lib$es6$promise$polyfill$$default
  	    };
  
  	    /* global define:true module:true window: true */
  	    if ("function" === 'function' && __webpack_require__(8)['amd']) {
  	      !(__WEBPACK_AMD_DEFINE_RESULT__ = function() { return lib$es6$promise$umd$$ES6Promise; }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  	    } else if (typeof module !== 'undefined' && module['exports']) {
  	      module['exports'] = lib$es6$promise$umd$$ES6Promise;
  	    } else if (typeof this !== 'undefined') {
  	      this['ES6Promise'] = lib$es6$promise$umd$$ES6Promise;
  	    }
  
  	    lib$es6$promise$polyfill$$default();
  	}).call(this);
  
  
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5), (function() { return this; }()), __webpack_require__(6)(module)))
  
  /***/ },
  /* 5 */
  /***/ 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() {
  	    if (!draining || !currentQueue) {
  	        return;
  	    }
  	    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; };
  
  
  /***/ },
  /* 6 */
  /***/ function(module, exports) {
  
  	module.exports = function(module) {
  		if(!module.webpackPolyfill) {
  			module.deprecate = function() {};
  			module.paths = [];
  			// module.parent = undefined by default
  			module.children = [];
  			module.webpackPolyfill = 1;
  		}
  		return module;
  	}
  
  
  /***/ },
  /* 7 */
  /***/ function(module, exports) {
  
  	/* (ignored) */
  
  /***/ },
  /* 8 */
  /***/ function(module, exports) {
  
  	module.exports = function() { throw new Error("define cannot be used indirect"); };
  
  
  /***/ },
  /* 9 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var assign = __webpack_require__(10);
  	var qs = __webpack_require__(11);
  	var request_models_1 = __webpack_require__(15);
  	var util_1 = __webpack_require__(16);
  	var Query = (function () {
  	    function Query(query) {
  	        if (query === void 0) { query = ''; }
  	        this.request = {};
  	        this.unprocessedNavigations = [];
  	        this.queryParams = {};
  	        this.request.query = query;
  	        this.request.sort = [];
  	        this.request.fields = [];
  	        this.request.orFields = [];
  	        this.request.refinements = [];
  	        this.request.customUrlParams = [];
  	        this.request.includedNavigations = [];
  	        this.request.excludedNavigations = [];
  	        this.request.wildcardSearchEnabled = false;
  	        this.request.pruneRefinements = true;
  	    }
  	    Query.prototype.withConfiguration = function (configuration) {
  	        assign(this.request, configuration);
  	        return this;
  	    };
  	    Query.prototype.withSelectedRefinements = function () {
  	        var refinements = [];
  	        for (var _i = 0; _i < arguments.length; _i++) {
  	            refinements[_i - 0] = arguments[_i];
  	        }
  	        (_a = this.request.refinements).push.apply(_a, refinements);
  	        return this;
  	        var _a;
  	    };
  	    Query.prototype.withRefinements = function (navigationName) {
  	        var refinements = [];
  	        for (var _i = 1; _i < arguments.length; _i++) {
  	            refinements[_i - 1] = arguments[_i];
  	        }
  	        var convert = function (refinement) { return assign(refinement, { navigationName: navigationName }); };
  	        (_a = this.request.refinements).push.apply(_a, refinements.map(convert));
  	        return this;
  	        var _a;
  	    };
  	    Query.prototype.withNavigations = function () {
  	        var navigations = [];
  	        for (var _i = 0; _i < arguments.length; _i++) {
  	            navigations[_i - 0] = arguments[_i];
  	        }
  	        (_a = this.unprocessedNavigations).push.apply(_a, navigations);
  	        return this;
  	        var _a;
  	    };
  	    Query.prototype.withCustomUrlParams = function (customUrlParams) {
  	        if (typeof customUrlParams === 'string') {
  	            (_a = this.request.customUrlParams).push.apply(_a, this.convertParamString(customUrlParams));
  	        }
  	        else if (customUrlParams instanceof Array) {
  	            (_b = this.request.customUrlParams).push.apply(_b, customUrlParams);
  	        }
  	        return this;
  	        var _a, _b;
  	    };
  	    Query.prototype.convertParamString = function (customUrlParams) {
  	        var parsed = qs.parse(customUrlParams);
  	        return Object.keys(parsed).reduce(function (converted, key) { return converted.concat({ key: key, value: parsed[key] }); }, []);
  	    };
  	    Query.prototype.withFields = function () {
  	        var fields = [];
  	        for (var _i = 0; _i < arguments.length; _i++) {
  	            fields[_i - 0] = arguments[_i];
  	        }
  	        (_a = this.request.fields).push.apply(_a, fields);
  	        return this;
  	        var _a;
  	    };
  	    Query.prototype.withOrFields = function () {
  	        var orFields = [];
  	        for (var _i = 0; _i < arguments.length; _i++) {
  	            orFields[_i - 0] = arguments[_i];
  	        }
  	        (_a = this.request.orFields).push.apply(_a, orFields);
  	        return this;
  	        var _a;
  	    };
  	    Query.prototype.withSorts = function () {
  	        var sorts = [];
  	        for (var _i = 0; _i < arguments.length; _i++) {
  	            sorts[_i - 0] = arguments[_i];
  	        }
  	        (_a = this.request.sort).push.apply(_a, sorts);
  	        return this;
  	        var _a;
  	    };
  	    Query.prototype.withIncludedNavigations = function () {
  	        var navigationNames = [];
  	        for (var _i = 0; _i < arguments.length; _i++) {
  	            navigationNames[_i - 0] = arguments[_i];
  	        }
  	        (_a = this.request.includedNavigations).push.apply(_a, navigationNames);
  	        return this;
  	        var _a;
  	    };
  	    Query.prototype.withExcludedNavigations = function () {
  	        var navigationNames = [];
  	        for (var _i = 0; _i < arguments.length; _i++) {
  	            navigationNames[_i - 0] = arguments[_i];
  	        }
  	        (_a = this.request.excludedNavigations).push.apply(_a, navigationNames);
  	        return this;
  	        var _a;
  	    };
  	    Query.prototype.withQueryParams = function (queryParams) {
  	        switch (typeof queryParams) {
  	            case 'string':
  	                return assign(this, { queryParams: this.convertQueryString(queryParams) });
  	            case 'object':
  	                return assign(this, { queryParams: queryParams });
  	        }
  	    };
  	    Query.prototype.convertQueryString = function (queryParams) {
  	        return qs.parse(queryParams);
  	    };
  	    Query.prototype.refineByValue = function (navigationName, value, exclude) {
  	        if (exclude === void 0) { exclude = false; }
  	        return this.withSelectedRefinements({
  	            navigationName: navigationName,
  	            value: value,
  	            exclude: exclude,
  	            type: 'Value'
  	        });
  	    };
  	    Query.prototype.refineByRange = function (navigationName, low, high, exclude) {
  	        if (exclude === void 0) { exclude = false; }
  	        return this.withSelectedRefinements({
  	            navigationName: navigationName,
  	            low: low,
  	            high: high,
  	            exclude: exclude,
  	            type: 'Range'
  	        });
  	    };
  	    Query.prototype.restrictNavigation = function (restrictNavigation) {
  	        this.request.restrictNavigation = restrictNavigation;
  	        return this;
  	    };
  	    Query.prototype.skip = function (skip) {
  	        this.request.skip = skip;
  	        return this;
  	    };
  	    Query.prototype.withPageSize = function (pageSize) {
  	        this.request.pageSize = pageSize;
  	        return this;
  	    };
  	    Query.prototype.withMatchStrategy = function (matchStrategy) {
  	        this.request.matchStrategy = matchStrategy;
  	        return this;
  	    };
  	    Query.prototype.withBiasing = function (biasing) {
  	        this.request.biasing = biasing;
  	        return this;
  	    };
  	    Query.prototype.enableWildcardSearch = function () {
  	        this.request.wildcardSearchEnabled = true;
  	        return this;
  	    };
  	    Query.prototype.disableAutocorrection = function () {
  	        this.request.disableAutocorrection = true;
  	        return this;
  	    };
  	    Query.prototype.disableBinaryPayload = function () {
  	        this.request.returnBinary = false;
  	        return this;
  	    };
  	    Query.prototype.allowPrunedRefinements = function () {
  	        this.request.pruneRefinements = false;
  	        return this;
  	    };
  	    Query.prototype.build = function () {
  	        var builtRequest = assign(new request_models_1.Request(), this.request);
  	        (_a = builtRequest.refinements).push.apply(_a, util_1.NavigationConverter.convert(this.unprocessedNavigations));
  	        return this.clearEmptyArrays(builtRequest);
  	        var _a;
  	    };
  	    Query.prototype.clearEmptyArrays = function (request) {
  	        for (var key in request) {
  	            if (request[key] instanceof Array && request[key].length === 0) {
  	                delete request[key];
  	            }
  	        }
  	        return request;
  	    };
  	    return Query;
  	}());
  	exports.Query = Query;
  
  	//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["core/query.ts"],"names":[],"mappings":"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","file":"core/query.js","sourcesContent":["import assign = require('object-assign');\nimport qs = require('qs');\nimport {\n  Request,\n  SelectedValueRefinement,\n  SelectedRangeRefinement,\n  SelectedRefinement,\n  CustomUrlParam,\n  RestrictNavigation,\n  Sort,\n  MatchStrategy,\n  Biasing,\n  Bias\n} from '../request-models';\nimport {\n  Results,\n  Record,\n  ValueRefinement,\n  RangeRefinement,\n  Refinement,\n  RefinementType,\n  Navigation\n} from '../response-models';\nimport { NavigationConverter } from '../util';\n\nexport interface QueryConfiguration {\n  userId?: string;\n  language?: string;\n  collection?: string;\n  area?: string;\n  biasingProfile?: string;\n}\n\nexport class Query {\n  private request: Request;\n  private unprocessedNavigations: Navigation[];\n  queryParams: any;\n\n  constructor(query: string = '') {\n    this.request = <Request>{};\n    this.unprocessedNavigations = [];\n    this.queryParams = {};\n\n    this.request.query = query;\n    this.request.sort = [];\n    this.request.fields = [];\n    this.request.orFields = [];\n    this.request.refinements = [];\n    this.request.customUrlParams = [];\n    this.request.includedNavigations = [];\n    this.request.excludedNavigations = [];\n\n    this.request.wildcardSearchEnabled = false;\n    this.request.pruneRefinements = true;\n  }\n\n  withConfiguration(configuration: QueryConfiguration): Query {\n    assign(this.request, configuration);\n    return this;\n  }\n\n  withSelectedRefinements(...refinements: Array<SelectedValueRefinement | SelectedRangeRefinement>): Query {\n    this.request.refinements.push(...refinements);\n    return this;\n  }\n\n  withRefinements(navigationName: string, ...refinements: Array<ValueRefinement | RangeRefinement>): Query {\n    let convert = (refinement: Refinement) => <SelectedRefinement>assign(refinement, { navigationName });\n    this.request.refinements.push(...refinements.map(convert));\n    return this;\n  }\n\n  withNavigations(...navigations: Navigation[]): Query {\n    this.unprocessedNavigations.push(...navigations);\n    return this;\n  }\n\n  withCustomUrlParams(customUrlParams: CustomUrlParam[] | string): Query {\n    if (typeof customUrlParams === 'string') {\n      this.request.customUrlParams.push(...this.convertParamString(customUrlParams));\n    } else if (customUrlParams instanceof Array) {\n      this.request.customUrlParams.push(...customUrlParams);\n    }\n    return this;\n  }\n\n  private convertParamString(customUrlParams: string): CustomUrlParam[] {\n    let parsed = qs.parse(customUrlParams);\n    return Object.keys(parsed).reduce((converted, key) => converted.concat({ key, value: parsed[key] }), []);\n  }\n\n  withFields(...fields: string[]): Query {\n    this.request.fields.push(...fields);\n    return this;\n  }\n\n  withOrFields(...orFields: string[]): Query {\n    this.request.orFields.push(...orFields);\n    return this;\n  }\n\n  withSorts(...sorts: Sort[]): Query {\n    this.request.sort.push(...sorts);\n    return this;\n  }\n\n  withIncludedNavigations(...navigationNames: string[]): Query {\n    this.request.includedNavigations.push(...navigationNames);\n    return this;\n  }\n\n  withExcludedNavigations(...navigationNames: string[]): Query {\n    this.request.excludedNavigations.push(...navigationNames);\n    return this;\n  }\n\n  withQueryParams(queryParams: any | string): Query {\n    switch (typeof queryParams) {\n      case 'string':\n        return assign(this, { queryParams: this.convertQueryString(<string>queryParams) });\n      case 'object':\n        return assign(this, { queryParams });\n    }\n  }\n\n  private convertQueryString(queryParams: string): any {\n    return qs.parse(queryParams);\n  }\n\n  refineByValue(navigationName: string, value: string, exclude: boolean = false): Query {\n    return this.withSelectedRefinements(<SelectedValueRefinement>{\n      navigationName,\n      value,\n      exclude,\n      type: 'Value'\n    });\n  }\n\n  refineByRange(navigationName: string, low: number, high: number, exclude: boolean = false): Query {\n    return this.withSelectedRefinements(<SelectedRangeRefinement>{\n      navigationName,\n      low,\n      high,\n      exclude,\n      type: 'Range'\n    });\n  }\n\n  restrictNavigation(restrictNavigation: RestrictNavigation): Query {\n    this.request.restrictNavigation = restrictNavigation;\n    return this;\n  }\n\n  skip(skip: number): Query {\n    this.request.skip = skip;\n    return this;\n  }\n\n  withPageSize(pageSize: number): Query {\n    this.request.pageSize = pageSize;\n    return this;\n  }\n\n  withMatchStrategy(matchStrategy: MatchStrategy): Query {\n    this.request.matchStrategy = matchStrategy;\n    return this;\n  }\n\n  withBiasing(biasing: Biasing): Query {\n    this.request.biasing = biasing;\n    return this;\n  }\n\n  enableWildcardSearch(): Query {\n    this.request.wildcardSearchEnabled = true;\n    return this;\n  }\n\n  disableAutocorrection(): Query {\n    this.request.disableAutocorrection = true;\n    return this;\n  }\n\n  disableBinaryPayload(): Query {\n    this.request.returnBinary = false;\n    return this;\n  }\n\n  allowPrunedRefinements(): Query {\n    this.request.pruneRefinements = false;\n    return this;\n  }\n\n  build(): Request {\n    let builtRequest = assign(new Request(), this.request);\n    builtRequest.refinements.push(...NavigationConverter.convert(this.unprocessedNavigations));\n\n    return this.clearEmptyArrays(builtRequest);\n  }\n\n  private clearEmptyArrays(request: Request): Request {\n    for (let key in request) {\n      if (request[key] instanceof Array && request[key].length === 0) {\n        delete request[key];\n      }\n    }\n    return request;\n  }\n\n}\n"],"sourceRoot":"/source/"}
  
  
  /***/ },
  /* 10 */
  /***/ function(module, exports) {
  
  	'use strict';
  	/* eslint-disable no-unused-vars */
  	var hasOwnProperty = Object.prototype.hasOwnProperty;
  	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
  
  	function toObject(val) {
  		if (val === null || val === undefined) {
  			throw new TypeError('Object.assign cannot be called with null or undefined');
  		}
  
  		return Object(val);
  	}
  
  	function shouldUseNative() {
  		try {
  			if (!Object.assign) {
  				return false;
  			}
  
  			// Detect buggy property enumeration order in older V8 versions.
  
  			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
  			var test1 = new String('abc');  // eslint-disable-line
  			test1[5] = 'de';
  			if (Object.getOwnPropertyNames(test1)[0] === '5') {
  				return false;
  			}
  
  			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  			var test2 = {};
  			for (var i = 0; i < 10; i++) {
  				test2['_' + String.fromCharCode(i)] = i;
  			}
  			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
  				return test2[n];
  			});
  			if (order2.join('') !== '0123456789') {
  				return false;
  			}
  
  			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  			var test3 = {};
  			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
  				test3[letter] = letter;
  			});
  			if (Object.keys(Object.assign({}, test3)).join('') !==
  					'abcdefghijklmnopqrst') {
  				return false;
  			}
  
  			return true;
  		} catch (e) {
  			// We don't expect any of the above to throw, but better to be safe.
  			return false;
  		}
  	}
  
  	module.exports = shouldUseNative() ? Object.assign : function (target, source) {
  		var from;
  		var to = toObject(target);
  		var symbols;
  
  		for (var s = 1; s < arguments.length; s++) {
  			from = Object(arguments[s]);
  
  			for (var key in from) {
  				if (hasOwnProperty.call(from, key)) {
  					to[key] = from[key];
  				}
  			}
  
  			if (Object.getOwnPropertySymbols) {
  				symbols = Object.getOwnPropertySymbols(from);
  				for (var i = 0; i < symbols.length; i++) {
  					if (propIsEnumerable.call(from, symbols[i])) {
  						to[symbols[i]] = from[symbols[i]];
  					}
  				}
  			}
  		}
  
  		return to;
  	};
  
  
  /***/ },
  /* 11 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var Stringify = __webpack_require__(12);
  	var Parse = __webpack_require__(14);
  
  	module.exports = {
  	    stringify: Stringify,
  	    parse: Parse
  	};
  
  
  /***/ },
  /* 12 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var Utils = __webpack_require__(13);
  
  	var arrayPrefixGenerators = {
  	    brackets: function brackets(prefix) {
  	        return prefix + '[]';
  	    },
  	    indices: function indices(prefix, key) {
  	        return prefix + '[' + key + ']';
  	    },
  	    repeat: function repeat(prefix) {
  	        return prefix;
  	    }
  	};
  
  	var defaults = {
  	    delimiter: '&',
  	    strictNullHandling: false,
  	    skipNulls: false,
  	    encode: true,
  	    encoder: Utils.encode
  	};
  
  	var stringify = function stringify(object, prefix, generateArrayPrefix, strictNullHandling, skipNulls, encoder, filter, sort, allowDots) {
  	    var obj = object;
  	    if (typeof filter === 'function') {
  	        obj = filter(prefix, obj);
  	    } else if (obj instanceof Date) {
  	        obj = obj.toISOString();
  	    } else if (obj === null) {
  	        if (strictNullHandling) {
  	            return encoder ? encoder(prefix) : prefix;
  	        }
  
  	        obj = '';
  	    }
  
  	    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean' || Utils.isBuffer(obj)) {
  	        if (encoder) {
  	            return [encoder(prefix) + '=' + encoder(obj)];
  	        }
  	        return [prefix + '=' + String(obj)];
  	    }
  
  	    var values = [];
  
  	    if (typeof obj === 'undefined') {
  	        return values;
  	    }
  
  	    var objKeys;
  	    if (Array.isArray(filter)) {
  	        objKeys = filter;
  	    } else {
  	        var keys = Object.keys(obj);
  	        objKeys = sort ? keys.sort(sort) : keys;
  	    }
  
  	    for (var i = 0; i < objKeys.length; ++i) {
  	        var key = objKeys[i];
  
  	        if (skipNulls && obj[key] === null) {
  	            continue;
  	        }
  
  	        if (Array.isArray(obj)) {
  	            values = values.concat(stringify(obj[key], generateArrayPrefix(prefix, key), generateArrayPrefix, strictNullHandling, skipNulls, encoder, filter, sort, allowDots));
  	        } else {
  	            values = values.concat(stringify(obj[key], prefix + (allowDots ? '.' + key : '[' + key + ']'), generateArrayPrefix, strictNullHandling, skipNulls, encoder, filter, sort, allowDots));
  	        }
  	    }
  
  	    return values;
  	};
  
  	module.exports = function (object, opts) {
  	    var obj = object;
  	    var options = opts || {};
  	    var delimiter = typeof options.delimiter === 'undefined' ? defaults.delimiter : options.delimiter;
  	    var strictNullHandling = typeof options.strictNullHandling === 'boolean' ? options.strictNullHandling : defaults.strictNullHandling;
  	    var skipNulls = typeof options.skipNulls === 'boolean' ? options.skipNulls : defaults.skipNulls;
  	    var encode = typeof options.encode === 'boolean' ? options.encode : defaults.encode;
  	    var encoder = encode ? (typeof options.encoder === 'function' ? options.encoder : defaults.encoder) : null;
  	    var sort = typeof options.sort === 'function' ? options.sort : null;
  	    var allowDots = typeof options.allowDots === 'undefined' ? false : options.allowDots;
  	    var objKeys;
  	    var filter;
  
  	    if (options.encoder !== null && options.encoder !== undefined && typeof options.encoder !== 'function') {
  	        throw new TypeError('Encoder has to be a function.');
  	    }
  
  	    if (typeof options.filter === 'function') {
  	        filter = options.filter;
  	        obj = filter('', obj);
  	    } else if (Array.isArray(options.filter)) {
  	        objKeys = filter = options.filter;
  	    }
  
  	    var keys = [];
  
  	    if (typeof obj !== 'object' || obj === null) {
  	        return '';
  	    }
  
  	    var arrayFormat;
  	    if (options.arrayFormat in arrayPrefixGenerators) {
  	        arrayFormat = options.arrayFormat;
  	    } else if ('indices' in options) {
  	        arrayFormat = options.indices ? 'indices' : 'repeat';
  	    } else {
  	        arrayFormat = 'indices';
  	    }
  
  	    var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];
  
  	    if (!objKeys) {
  	        objKeys = Object.keys(obj);
  	    }
  
  	    if (sort) {
  	        objKeys.sort(sort);
  	    }
  
  	    for (var i = 0; i < objKeys.length; ++i) {
  	        var key = objKeys[i];
  
  	        if (skipNulls && obj[key] === null) {
  	            continue;
  	        }
  
  	        keys = keys.concat(stringify(obj[key], key, generateArrayPrefix, strictNullHandling, skipNulls, encoder, filter, sort, allowDots));
  	    }
  
  	    return keys.join(delimiter);
  	};
  
  
  /***/ },
  /* 13 */
  /***/ function(module, exports) {
  
  	'use strict';
  
  	var hexTable = (function () {
  	    var array = new Array(256);
  	    for (var i = 0; i < 256; ++i) {
  	        array[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();
  	    }
  
  	    return array;
  	}());
  
  	exports.arrayToObject = function (source, options) {
  	    var obj = options.plainObjects ? Object.create(null) : {};
  	    for (var i = 0; i < source.length; ++i) {
  	        if (typeof source[i] !== 'undefined') {
  	            obj[i] = source[i];
  	        }
  	    }
  
  	    return obj;
  	};
  
  	exports.merge = function (target, source, options) {
  	    if (!source) {
  	        return target;
  	    }
  
  	    if (typeof source !== 'object') {
  	        if (Array.isArray(target)) {
  	            target.push(source);
  	        } else if (typeof target === 'object') {
  	            target[source] = true;
  	        } else {
  	            return [target, source];
  	        }
  
  	        return target;
  	    }
  
  	    if (typeof target !== 'object') {
  	        return [target].concat(source);
  	    }
  
  	    var mergeTarget = target;
  	    if (Array.isArray(target) && !Array.isArray(source)) {
  	        mergeTarget = exports.arrayToObject(target, options);
  	    }
  
  	    return Object.keys(source).reduce(function (acc, key) {
  	        var value = source[key];
  
  	        if (Object.prototype.hasOwnProperty.call(acc, key)) {
  	            acc[key] = exports.merge(acc[key], value, options);
  	        } else {
  	            acc[key] = value;
  	        }
  	        return acc;
  	    }, mergeTarget);
  	};
  
  	exports.decode = function (str) {
  	    try {
  	        return decodeURIComponent(str.replace(/\+/g, ' '));
  	    } catch (e) {
  	        return str;
  	    }
  	};
  
  	exports.encode = function (str) {
  	    // This code was originally written by Brian White (mscdex) for the io.js core querystring library.
  	    // It has been adapted here for stricter adherence to RFC 3986
  	    if (str.length === 0) {
  	        return str;
  	    }
  
  	    var string = typeof str === 'string' ? str : String(str);
  
  	    var out = '';
  	    for (var i = 0; i < string.length; ++i) {
  	        var c = string.charCodeAt(i);
  
  	        if (
  	            c === 0x2D || // -
  	            c === 0x2E || // .
  	            c === 0x5F || // _
  	            c === 0x7E || // ~
  	            (c >= 0x30 && c <= 0x39) || // 0-9
  	            (c >= 0x41 && c <= 0x5A) || // a-z
  	            (c >= 0x61 && c <= 0x7A) // A-Z
  	        ) {
  	            out += string.charAt(i);
  	            continue;
  	        }
  
  	        if (c < 0x80) {
  	            out = out + hexTable[c];
  	            continue;
  	        }
  
  	        if (c < 0x800) {
  	            out = out + (hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)]);
  	            continue;
  	        }
  
  	        if (c < 0xD800 || c >= 0xE000) {
  	            out = out + (hexTable[0xE0 | (c >> 12)] + hexTable[0x80 | ((c >> 6) & 0x3F)] + hexTable[0x80 | (c & 0x3F)]);
  	            continue;
  	        }
  
  	        i += 1;
  	        c = 0x10000 + (((c & 0x3FF) << 10) | (string.charCodeAt(i) & 0x3FF));
  	        out += hexTable[0xF0 | (c >> 18)] + hexTable[0x80 | ((c >> 12) & 0x3F)] + hexTable[0x80 | ((c >> 6) & 0x3F)] + hexTable[0x80 | (c & 0x3F)];
  	    }
  
  	    return out;
  	};
  
  	exports.compact = function (obj, references) {
  	    if (typeof obj !== 'object' || obj === null) {
  	        return obj;
  	    }
  
  	    var refs = references || [];
  	    var lookup = refs.indexOf(obj);
  	    if (lookup !== -1) {
  	        return refs[lookup];
  	    }
  
  	    refs.push(obj);
  
  	    if (Array.isArray(obj)) {
  	        var compacted = [];
  
  	        for (var i = 0; i < obj.length; ++i) {
  	            if (obj[i] && typeof obj[i] === 'object') {
  	                compacted.push(exports.compact(obj[i], refs));
  	            } else if (typeof obj[i] !== 'undefined') {
  	                compacted.push(obj[i]);
  	            }
  	        }
  
  	        return compacted;
  	    }
  
  	    var keys = Object.keys(obj);
  	    for (var j = 0; j < keys.length; ++j) {
  	        var key = keys[j];
  	        obj[key] = exports.compact(obj[key], refs);
  	    }
  
  	    return obj;
  	};
  
  	exports.isRegExp = function (obj) {
  	    return Object.prototype.toString.call(obj) === '[object RegExp]';
  	};
  
  	exports.isBuffer = function (obj) {
  	    if (obj === null || typeof obj === 'undefined') {
  	        return false;
  	    }
  
  	    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
  	};
  
  
  /***/ },
  /* 14 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var Utils = __webpack_require__(13);
  
  	var defaults = {
  	    delimiter: '&',
  	    depth: 5,
  	    arrayLimit: 20,
  	    parameterLimit: 1000,
  	    strictNullHandling: false,
  	    plainObjects: false,
  	    allowPrototypes: false,
  	    allowDots: false,
  	    decoder: Utils.decode
  	};
  
  	var parseValues = function parseValues(str, options) {
  	    var obj = {};
  	    var parts = str.split(options.delimiter, options.parameterLimit === Infinity ? undefined : options.parameterLimit);
  
  	    for (var i = 0; i < parts.length; ++i) {
  	        var part = parts[i];
  	        var pos = part.indexOf(']=') === -1 ? part.indexOf('=') : part.indexOf(']=') + 1;
  
  	        if (pos === -1) {
  	            obj[options.decoder(part)] = '';
  
  	            if (options.strictNullHandling) {
  	                obj[options.decoder(part)] = null;
  	            }
  	        } else {
  	            var key = options.decoder(part.slice(0, pos));
  	            var val = options.decoder(part.slice(pos + 1));
  
  	            if (Object.prototype.hasOwnProperty.call(obj, key)) {
  	                obj[key] = [].concat(obj[key]).concat(val);
  	            } else {
  	                obj[key] = val;
  	            }
  	        }
  	    }
  
  	    return obj;
  	};
  
  	var parseObject = function parseObject(chain, val, options) {
  	    if (!chain.length) {
  	        return val;
  	    }
  
  	    var root = chain.shift();
  
  	    var obj;
  	    if (root === '[]') {
  	        obj = [];
  	        obj = obj.concat(parseObject(chain, val, options));
  	    } else {
  	        obj = options.plainObjects ? Object.create(null) : {};
  	        var cleanRoot = root[0] === '[' && root[root.length - 1] === ']' ? root.slice(1, root.length - 1) : root;
  	        var index = parseInt(cleanRoot, 10);
  	        if (
  	            !isNaN(index) &&
  	            root !== cleanRoot &&
  	            String(index) === cleanRoot &&
  	            index >= 0 &&
  	            (options.parseArrays && index <= options.arrayLimit)
  	        ) {
  	            obj = [];
  	            obj[index] = parseObject(chain, val, options);
  	        } else {
  	            obj[cleanRoot] = parseObject(chain, val, options);
  	        }
  	    }
  
  	    return obj;
  	};
  
  	var parseKeys = function parseKeys(givenKey, val, options) {
  	    if (!givenKey) {
  	        return;
  	    }
  
  	    // Transform dot notation to bracket notation
  	    var key = options.allowDots ? givenKey.replace(/\.([^\.\[]+)/g, '[$1]') : givenKey;
  
  	    // The regex chunks
  
  	    var parent = /^([^\[\]]*)/;
  	    var child = /(\[[^\[\]]*\])/g;
  
  	    // Get the parent
  
  	    var segment = parent.exec(key);
  
  	    // Stash the parent if it exists
  
  	    var keys = [];
  	    if (segment[1]) {
  	        // If we aren't using plain objects, optionally prefix keys
  	        // that would overwrite object prototype properties
  	        if (!options.plainObjects && Object.prototype.hasOwnProperty(segment[1])) {
  	            if (!options.allowPrototypes) {
  	                return;
  	            }
  	        }
  
  	        keys.push(segment[1]);
  	    }
  
  	    // Loop through children appending to the array until we hit depth
  
  	    var i = 0;
  	    while ((segment = child.exec(key)) !== null && i < options.depth) {
  	        i += 1;
  	        if (!options.plainObjects && Object.prototype.hasOwnProperty(segment[1].replace(/\[|\]/g, ''))) {
  	            if (!options.allowPrototypes) {
  	                continue;
  	            }
  	        }
  	        keys.push(segment[1]);
  	    }
  
  	    // If there's a remainder, just add whatever is left
  
  	    if (segment) {
  	        keys.push('[' + key.slice(segment.index) + ']');
  	    }
  
  	    return parseObject(keys, val, options);
  	};
  
  	module.exports = function (str, opts) {
  	    var options = opts || {};
  
  	    if (options.decoder !== null && options.decoder !== undefined && typeof options.decoder !== 'function') {
  	        throw new TypeError('Decoder has to be a function.');
  	    }
  
  	    options.delimiter = typeof options.delimiter === 'string' || Utils.isRegExp(options.delimiter) ? options.delimiter : defaults.delimiter;
  	    options.depth = typeof options.depth === 'number' ? options.depth : defaults.depth;
  	    options.arrayLimit = typeof options.arrayLimit === 'number' ? options.arrayLimit : defaults.arrayLimit;
  	    options.parseArrays = options.parseArrays !== false;
  	    options.decoder = typeof options.decoder === 'function' ? options.decoder : defaults.decoder;
  	    options.allowDots = typeof options.allowDots === 'boolean' ? options.allowDots : defaults.allowDots;
  	    options.plainObjects = typeof options.plainObjects === 'boolean' ? options.plainObjects : defaults.plainObjects;
  	    options.allowPrototypes = typeof options.allowPrototypes === 'boolean' ? options.allowPrototypes : defaults.allowPrototypes;
  	    options.parameterLimit = typeof options.parameterLimit === 'number' ? options.parameterLimit : defaults.parameterLimit;
  	    options.strictNullHandling = typeof options.strictNullHandling === 'boolean' ? options.strictNullHandling : defaults.strictNullHandling;
  
  	    if (str === '' || str === null || typeof str === 'undefined') {
  	        return options.plainObjects ? Object.create(null) : {};
  	    }
  
  	    var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
  	    var obj = options.plainObjects ? Object.create(null) : {};
  
  	    // Iterate over the keys and setup the new object
  
  	    var keys = Object.keys(tempObj);
  	    for (var i = 0; i < keys.length; ++i) {
  	        var key = keys[i];
  	        var newObj = parseKeys(key, tempObj[key], options);
  	        obj = Utils.merge(obj, newObj, options);
  	    }
  
  	    return Utils.compact(obj);
  	};
  
  
  /***/ },
  /* 15 */
  /***/ function(module, exports) {
  
  	"use strict";
  	var Request = (function () {
  	    function Request() {
  	    }
  	    return Request;
  	}());
  	exports.Request = Request;
  
  	//# sourceMappingURL=data:application/json;base64,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
  
  
  /***/ },
  /* 16 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var assign = __webpack_require__(10);
  	var NavigationConverter = (function () {
  	    function NavigationConverter() {
  	    }
  	    NavigationConverter.convert = function (navigations) {
  	        return navigations.reduce(function (refinements, navigation) {
  	            navigation.refinements.forEach(function (refinement) { return refinements.push(assign(refinement, { navigationName: navigation.name })); });
  	            return refinements;
  	        }, []);
  	    };
  	    return NavigationConverter;
  	}());
  	exports.NavigationConverter = NavigationConverter;
  
  	//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLElBQU8sTUFBTSxXQUFXLGVBQWUsQ0FBQyxDQUFDO0FBSXpDO0lBQUE7SUFPQSxDQUFDO0lBTlEsMkJBQU8sR0FBZCxVQUFlLFdBQThCO1FBQzNDLE1BQU0sQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLFVBQUMsV0FBc0MsRUFBRSxVQUFzQjtZQUN2RixVQUFVLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxVQUFBLFVBQVUsSUFBSSxPQUFBLFdBQVcsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFBRSxFQUFFLGNBQWMsRUFBRSxVQUFVLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxFQUF6RSxDQUF5RSxDQUFDLENBQUM7WUFDeEgsTUFBTSxDQUFDLFdBQVcsQ0FBQztRQUNyQixDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDVCxDQUFDO0lBQ0gsMEJBQUM7QUFBRCxDQVBBLEFBT0MsSUFBQTtBQVBZLDJCQUFtQixzQkFPL0IsQ0FBQSIsImZpbGUiOiJ1dGlsLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGFzc2lnbiA9IHJlcXVpcmUoJ29iamVjdC1hc3NpZ24nKTtcbmltcG9ydCB7IFNlbGVjdGVkUmVmaW5lbWVudCB9IGZyb20gJy4vcmVxdWVzdC1tb2RlbHMnO1xuaW1wb3J0IHsgTmF2aWdhdGlvbiB9IGZyb20gJy4vcmVzcG9uc2UtbW9kZWxzJztcblxuZXhwb3J0IGNsYXNzIE5hdmlnYXRpb25Db252ZXJ0ZXIge1xuICBzdGF0aWMgY29udmVydChuYXZpZ2F0aW9uczogQXJyYXk8TmF2aWdhdGlvbj4pOiBBcnJheTxTZWxlY3RlZFJlZmluZW1lbnQ+IHtcbiAgICByZXR1cm4gbmF2aWdhdGlvbnMucmVkdWNlKChyZWZpbmVtZW50czogQXJyYXk8U2VsZWN0ZWRSZWZpbmVtZW50PiwgbmF2aWdhdGlvbjogTmF2aWdhdGlvbikgPT4ge1xuICAgICAgbmF2aWdhdGlvbi5yZWZpbmVtZW50cy5mb3JFYWNoKHJlZmluZW1lbnQgPT4gcmVmaW5lbWVudHMucHVzaChhc3NpZ24ocmVmaW5lbWVudCwgeyBuYXZpZ2F0aW9uTmFtZTogbmF2aWdhdGlvbi5uYW1lIH0pKSk7XG4gICAgICByZXR1cm4gcmVmaW5lbWVudHM7XG4gICAgfSwgW10pO1xuICB9XG59XG4iXSwic291cmNlUm9vdCI6Ii9zb3VyY2UvIn0=
  
  
  /***/ },
  /* 17 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	var __extends = (this && this.__extends) || function (d, b) {
  	    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  	    function __() { this.constructor = d; }
  	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  	var axios = __webpack_require__(18);
  	var assign = __webpack_require__(10);
  	var query_1 = __webpack_require__(9);
  	var SEARCH = '/search';
  	var REFINEMENTS = '/refinements';
  	var REFINEMENT_SEARCH = '/refinement';
  	var CLUSTER = '/cluster';
  	var BIASING_DEFAULTS = {
  	    biases: [],
  	    bringToTop: [],
  	    augmentBiases: false
  	};
  	var AbstractBridge = (function () {
  	    function AbstractBridge() {
  	    }
  	    AbstractBridge.prototype.search = function (query, callback) {
  	        if (callback === void 0) { callback = undefined; }
  	        var _a = this.extractRequest(query), request = _a[0], queryParams = _a[1];
  	        if (request === null)
  	            return this.generateError('query was not of a recognised type', callback);
  	        var response = this.fireRequest(this.bridgeUrl, request, queryParams);
  	        if (callback) {
  	            response.then(function (res) { return callback(undefined, res); })
  	                .catch(function (err) { return callback(err); });
  	        }
  	        else {
  	            return response;
  	        }
  	    };
  	    AbstractBridge.prototype.extractRequest = function (query) {
  	        switch (typeof query) {
  	            case 'string': return [new query_1.Query(query).build(), {}];
  	            case 'object':
  	                if (query instanceof query_1.Query)
  	                    return [query.build(), query.queryParams];
  	                else
  	                    return [query, {}];
  	            default: return [null, null];
  	        }
  	    };
  	    AbstractBridge.prototype.generateError = function (error, callback) {
  	        var err = new Error(error);
  	        if (callback)
  	            callback(err);
  	        else
  	            return Promise.reject(err);
  	    };
  	    AbstractBridge.prototype.fireRequest = function (url, body, queryParams) {
  	        var _this = this;
  	        var options = {
  	            url: this.bridgeUrl,
  	            method: 'post',
  	            params: queryParams,
  	            data: this.augmentRequest(body),
  	            responseType: 'json',
  	            timeout: 1500
  	        };
  	        return axios(options)
  	            .then(function (res) { return res.data; })
  	            .then(function (res) { return res.records ? assign(res, { records: res.records.map(_this.convertRecordFields) }) : res; });
  	    };
  	    AbstractBridge.prototype.convertRecordFields = function (record) {
  	        var converted = assign(record, { id: record._id, url: record._u, title: record._t });
  	        delete converted._id, converted._u, converted._t;
  	        if (record._snippet) {
  	            converted.snippet = record._snippet;
  	            delete converted._snippet;
  	        }
  	        return converted;
  	    };
  	    return AbstractBridge;
  	}());
  	exports.AbstractBridge = AbstractBridge;
  	var CloudBridge = (function (_super) {
  	    __extends(CloudBridge, _super);
  	    function CloudBridge(clientKey, customerId) {
  	        _super.call(this);
  	        this.clientKey = clientKey;
  	        this.bridgeRefinementsUrl = null;
  	        this.bridgeRefinementsSearchUrl = null;
  	        this.bridgeClusterUrl = null;
  	        var baseUrl = "https://" + customerId + ".groupbycloud.com:443/api/v1";
  	        this.bridgeUrl = baseUrl + SEARCH;
  	        this.bridgeRefinementsUrl = baseUrl + REFINEMENTS;
  	        this.bridgeRefinementsSearchUrl = baseUrl + REFINEMENT_SEARCH;
  	        this.bridgeClusterUrl = baseUrl + CLUSTER;
  	    }
  	    CloudBridge.prototype.augmentRequest = function (request) {
  	        return assign(request, { clientKey: this.clientKey });
  	    };
  	    return CloudBridge;
  	}(AbstractBridge));
  	exports.CloudBridge = CloudBridge;
  	var BrowserBridge = (function (_super) {
  	    __extends(BrowserBridge, _super);
  	    function BrowserBridge(customerId) {
  	        _super.call(this);
  	        this.bridgeUrl = "http://ecomm.groupbycloud.com/semanticSearch/" + customerId;
  	    }
  	    BrowserBridge.prototype.augmentRequest = function (request) {
  	        return request;
  	    };
  	    return BrowserBridge;
  	}(AbstractBridge));
  	exports.BrowserBridge = BrowserBridge;
  
  	//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["core/bridge.ts"],"names":[],"mappings":"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","file":"core/bridge.js","sourcesContent":["import axios = require('axios');\nimport assign = require('object-assign');\nimport { Request } from '../request-models';\nimport { Results, Record } from '../response-models';\nimport { Query } from './query';\n\nconst SEARCH = '/search';\nconst REFINEMENTS = '/refinements';\nconst REFINEMENT_SEARCH = '/refinement';\nconst CLUSTER = '/cluster';\nconst BIASING_DEFAULTS = {\n  biases: [],\n  bringToTop: [],\n  augmentBiases: false\n};\n\nexport interface RawRecord extends Record {\n  _id: string;\n  _u: string;\n  _t: string;\n  _snippet?: string;\n}\n\nexport abstract class AbstractBridge {\n  protected bridgeUrl: string;\n\n  protected abstract augmentRequest(request: any): any;\n\n  search(query: string | Query | Request, callback: (Error?, Results?) => void = undefined): PromiseLike<Results> | void {\n    let [request, queryParams] = this.extractRequest(query);\n    if (request === null) return this.generateError('query was not of a recognised type', callback);\n\n    const response = this.fireRequest(this.bridgeUrl, request, queryParams);\n    if (callback) {\n      response.then(res => callback(undefined, res))\n        .catch(err => callback(err));\n    } else {\n      return response;\n    }\n  }\n\n  private extractRequest(query: any): [Request, any] {\n    switch (typeof query) {\n      case 'string': return [new Query(<string>query).build(), {}];\n      case 'object':\n        if (query instanceof Query) return [query.build(), query.queryParams];\n        else return [query, {}];\n      default: return [null, null];\n    }\n  }\n\n  private generateError(error: string, callback: (Error) => void): void | PromiseLike<any> {\n    const err = new Error(error);\n    if (callback) callback(err);\n    else return Promise.reject(err);\n  }\n\n  private fireRequest(url: string, body: Request | any, queryParams: any): Axios.IPromise<Results> {\n    const options = {\n      url: this.bridgeUrl,\n      method: 'post',\n      params: queryParams,\n      data: this.augmentRequest(body),\n      responseType: 'json',\n      timeout: 1500\n    };\n    return axios(options)\n      .then(res => res.data)\n      .then(res => res.records ? assign(res, { records: res.records.map(this.convertRecordFields) }) : res);\n  }\n\n  private convertRecordFields(record: RawRecord): Record | RawRecord {\n    const converted = assign(record, { id: record._id, url: record._u, title: record._t });\n    delete converted._id, converted._u, converted._t;\n\n    if (record._snippet) {\n      converted.snippet = record._snippet;\n      delete converted._snippet;\n    }\n\n    return converted;\n  }\n}\n\nexport class CloudBridge extends AbstractBridge {\n\n  private bridgeRefinementsUrl: string = null;\n  private bridgeRefinementsSearchUrl: string = null;\n  private bridgeClusterUrl: string = null;\n\n  constructor(private clientKey: string, customerId: string) {\n    super();\n    const baseUrl = `https://${customerId}.groupbycloud.com:443/api/v1`;\n    this.bridgeUrl = baseUrl + SEARCH;\n    this.bridgeRefinementsUrl = baseUrl + REFINEMENTS;\n    this.bridgeRefinementsSearchUrl = baseUrl + REFINEMENT_SEARCH;\n    this.bridgeClusterUrl = baseUrl + CLUSTER;\n  }\n\n  protected augmentRequest(request: any): any {\n    return assign(request, { clientKey: this.clientKey });\n  }\n}\n\nexport class BrowserBridge extends AbstractBridge {\n  constructor(customerId: string) {\n    super();\n    this.bridgeUrl = `http://ecomm.groupbycloud.com/semanticSearch/${customerId}`;\n  }\n\n  protected augmentRequest(request: any): any {\n    return request;\n  }\n}\n"],"sourceRoot":"/source/"}
  
  
  /***/ },
  /* 18 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(19);
  
  /***/ },
  /* 19 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var defaults = __webpack_require__(20);
  	var utils = __webpack_require__(21);
  	var dispatchRequest = __webpack_require__(22);
  	var InterceptorManager = __webpack_require__(30);
  	var isAbsoluteURL = __webpack_require__(31);
  	var combineURLs = __webpack_require__(32);
  	var bind = __webpack_require__(33);
  	var transformData = __webpack_require__(26);
  
  	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__(34);
  
  	// 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);
  	});
  
  
  /***/ },
  /* 20 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var utils = __webpack_require__(21);
  
  	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'
  	};
  
  
  /***/ },
  /* 21 */
  /***/ 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
  	};
  
  
  /***/ },
  /* 22 */
  /***/ 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__(23);
  	      } else if (typeof process !== 'undefined') {
  	        // For node use HTTP adapter
  	        adapter = __webpack_require__(23);
  	      }
  
  	      if (typeof adapter === 'function') {
  	        adapter(resolve, reject, config);
  	      }
  	    } catch (e) {
  	      reject(e);
  	    }
  	  });
  	};
  
  
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))
  
  /***/ },
  /* 23 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var utils = __webpack_require__(21);
  	var buildURL = __webpack_require__(24);
  	var parseHeaders = __webpack_require__(25);
  	var transformData = __webpack_require__(26);
  	var isURLSameOrigin = __webpack_require__(27);
  	var btoa = window.btoa || __webpack_require__(28);
  
  	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__(29);
  
  	    // 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);
  	};
  
  
  /***/ },
  /* 24 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var utils = __webpack_require__(21);
  
  	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;
  	};
  
  
  
  /***/ },
  /* 25 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var utils = __webpack_require__(21);
  
  	/**
  	 * 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;
  	};
  
  
  /***/ },
  /* 26 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var utils = __webpack_require__(21);
  
  	/**
  	 * 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;
  	};
  
  
  /***/ },
  /* 27 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var utils = __webpack_require__(21);
  
  	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;
  	    };
  	  })()
  	);
  
  
  /***/ },
  /* 28 */
  /***/ 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;
  
  
  /***/ },
  /* 29 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var utils = __webpack_require__(21);
  
  	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() {}
  	    };
  	  })()
  	);
  
  
  /***/ },
  /* 30 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var utils = __webpack_require__(21);
  
  	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;
  
  
  /***/ },
  /* 31 */
  /***/ 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);
  	};
  
  
  /***/ },
  /* 32 */
  /***/ 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(/^\/+/, '');
  	};
  
  
  /***/ },
  /* 33 */
  /***/ 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);
  	  };
  	};
  
  
  /***/ },
  /* 34 */
  /***/ 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);
  	  };
  	};
  
  
  /***/ },
  /* 35 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var __WEBPACK_AMD_DEFINE_RESULT__;/* Riot v2.4.1, @license MIT */
  
  	;(function(window, undefined) {
  	  'use strict';
  	var riot = { version: 'v2.4.1', settings: {} },
  	  // be aware, internal usage
  	  // ATTENTION: prefix the global dynamic variables with `__`
  
  	  // counter to give a unique id to all the Tag instances
  	  __uid = 0,
  	  // tags instances cache
  	  __virtualDom = [],
  	  // tags implementation cache
  	  __tagImpl = {},
  
  	  /**
  	   * Const
  	   */
  	  GLOBAL_MIXIN = '__global_mixin',
  
  	  // riot specific prefixes
  	  RIOT_PREFIX = 'riot-',
  	  RIOT_TAG = RIOT_PREFIX + 'tag',
  	  RIOT_TAG_IS = 'data-is',
  
  	  // for typeof == '' comparisons
  	  T_STRING = 'string',
  	  T_OBJECT = 'object',
  	  T_UNDEF  = 'undefined',
  	  T_FUNCTION = 'function',
  	  // special native tags that cannot be treated like the others
  	  SPECIAL_TAGS_REGEX = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?|opt(?:ion|group))$/,
  	  RESERVED_WORDS_BLACKLIST = /^(?:_(?:item|id|parent)|update|root|(?:un)?mount|mixin|is(?:Mounted|Loop)|tags|parent|opts|trigger|o(?:n|ff|ne))$/,
  	  // SVG tags list https://www.w3.org/TR/SVG/attindex.html#PresentationAttributes
  	  SVG_TAGS_LIST = ['altGlyph', 'animate', 'animateColor', 'circle', 'clipPath', 'defs', 'ellipse', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feFlood', 'feGaussianBlur', 'feImage', 'feMerge', 'feMorphology', 'feOffset', 'feSpecularLighting', 'feTile', 'feTurbulence', 'filter', 'font', 'foreignObject', 'g', 'glyph', 'glyphRef', 'image', 'line', 'linearGradient', 'marker', 'mask', 'missing-glyph', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'switch', 'symbol', 'text', 'textPath', 'tref', 'tspan', 'use'],
  
  	  // version# for IE 8-11, 0 for others
  	  IE_VERSION = (window && window.document || {}).documentMode | 0,
  
  	  // detect firefox to fix #1374
  	  FIREFOX = window && !!window.InstallTrigger
  	/* istanbul ignore next */
  	riot.observable = function(el) {
  
  	  /**
  	   * Extend the original object or create a new empty one
  	   * @type { Object }
  	   */
  
  	  el = el || {}
  
  	  /**
  	   * Private variables
  	   */
  	  var callbacks = {},
  	    slice = Array.prototype.slice
  
  	  /**
  	   * Private Methods
  	   */
  
  	  /**
  	   * Helper function needed to get and loop all the events in a string
  	   * @param   { String }   e - event string
  	   * @param   {Function}   fn - callback
  	   */
  	  function onEachEvent(e, fn) {
  	    var es = e.split(' '), l = es.length, i = 0, name, indx
  	    for (; i < l; i++) {
  	      name = es[i]
  	      indx = name.indexOf('.')
  	      if (name) fn( ~indx ? name.substring(0, indx) : name, i, ~indx ? name.slice(indx + 1) : null)
  	    }
  	  }
  
  	  /**
  	   * Public Api
  	   */
  
  	  // extend the el object adding the observable methods
  	  Object.defineProperties(el, {
  	    /**
  	     * Listen to the given space separated list of `events` and
  	     * execute the `callback` each time an event is triggered.
  	     * @param  { String } events - events ids
  	     * @param  { Function } fn - callback function
  	     * @returns { Object } el
  	     */
  	    on: {
  	      value: function(events, fn) {
  	        if (typeof fn != 'function')  return el
  
  	        onEachEvent(events, function(name, pos, ns) {
  	          (callbacks[name] = callbacks[name] || []).push(fn)
  	          fn.typed = pos > 0
  	          fn.ns = ns
  	        })
  
  	        return el
  	      },
  	      enumerable: false,
  	      writable: false,
  	      configurable: false
  	    },
  
  	    /**
  	     * Removes the given space separated list of `events` listeners
  	     * @param   { String } events - events ids
  	     * @param   { Function } fn - callback function
  	     * @returns { Object } el
  	     */
  	    off: {
  	      value: function(events, fn) {
  	        if (events == '*' && !fn) callbacks = {}
  	        else {
  	          onEachEvent(events, function(name, pos, ns) {
  	            if (fn || ns) {
  	              var arr = callbacks[name]
  	              for (var i = 0, cb; cb = arr && arr[i]; ++i) {
  	                if (cb == fn || ns && cb.ns == ns) arr.splice(i--, 1)
  	              }
  	            } else delete callbacks[name]
  	          })
  	        }
  	        return el
  	      },
  	      enumerable: false,
  	      writable: false,
  	      configurable: false
  	    },
  
  	    /**
  	     * Listen to the given space separated list of `events` and
  	     * execute the `callback` at most once
  	     * @param   { String } events - events ids
  	     * @param   { Function } fn - callback function
  	     * @returns { Object } el
  	     */
  	    one: {
  	      value: function(events, fn) {
  	        function on() {
  	          el.off(events, on)
  	          fn.apply(el, arguments)
  	        }
  	        return el.on(events, on)
  	      },
  	      enumerable: false,
  	      writable: false,
  	      configurable: false
  	    },
  
  	    /**
  	     * Execute all callback functions that listen to
  	     * the given space separated list of `events`
  	     * @param   { String } events - events ids
  	     * @returns { Object } el
  	     */
  	    trigger: {
  	      value: function(events) {
  
  	        // getting the arguments
  	        var arglen = arguments.length - 1,
  	          args = new Array(arglen),
  	          fns
  
  	        for (var i = 0; i < arglen; i++) {
  	          args[i] = arguments[i + 1] // skip first argument
  	        }
  
  	        onEachEvent(events, function(name, pos, ns) {
  
  	          fns = slice.call(callbacks[name] || [], 0)
  
  	          for (var i = 0, fn; fn = fns[i]; ++i) {
  	            if (fn.busy) continue
  	            fn.busy = 1
  	            if (!ns || fn.ns == ns) fn.apply(el, fn.typed ? [name].concat(args) : args)
  	            if (fns[i] !== fn) { i-- }
  	            fn.busy = 0
  	          }
  
  	          if (callbacks['*'] && name != '*')
  	            el.trigger.apply(el, ['*', name].concat(args))
  
  	        })
  
  	        return el
  	      },
  	      enumerable: false,
  	      writable: false,
  	      configurable: false
  	    }
  	  })
  
  	  return el
  
  	}
  	/* istanbul ignore next */
  	;(function(riot) {
  
  	/**
  	 * Simple client-side router
  	 * @module riot-route
  	 */
  
  
  	var RE_ORIGIN = /^.+?\/\/+[^\/]+/,
  	  EVENT_LISTENER = 'EventListener',
  	  REMOVE_EVENT_LISTENER = 'remove' + EVENT_LISTENER,
  	  ADD_EVENT_LISTENER = 'add' + EVENT_LISTENER,
  	  HAS_ATTRIBUTE = 'hasAttribute',
  	  REPLACE = 'replace',
  	  POPSTATE = 'popstate',
  	  HASHCHANGE = 'hashchange',
  	  TRIGGER = 'trigger',
  	  MAX_EMIT_STACK_LEVEL = 3,
  	  win = typeof window != 'undefined' && window,
  	  doc = typeof document != 'undefined' && document,
  	  hist = win && history,
  	  loc = win && (hist.location || win.location), // see html5-history-api
  	  prot = Router.prototype, // to minify more
  	  clickEvent = doc && doc.ontouchstart ? 'touchstart' : 'click',
  	  started = false,
  	  central = riot.observable(),
  	  routeFound = false,
  	  debouncedEmit,
  	  base, current, parser, secondParser, emitStack = [], emitStackLevel = 0
  
  	/**
  	 * Default parser. You can replace it via router.parser method.
  	 * @param {string} path - current path (normalized)
  	 * @returns {array} array
  	 */
  	function DEFAULT_PARSER(path) {
  	  return path.split(/[/?#]/)
  	}
  
  	/**
  	 * Default parser (second). You can replace it via router.parser method.
  	 * @param {string} path - current path (normalized)
  	 * @param {string} filter - filter string (normalized)
  	 * @returns {array} array
  	 */
  	function DEFAULT_SECOND_PARSER(path, filter) {
  	  var re = new RegExp('^' + filter[REPLACE](/\*/g, '([^/?#]+?)')[REPLACE](/\.\./, '.*') + '$'),
  	    args = path.match(re)
  
  	  if (args) return args.slice(1)
  	}
  
  	/**
  	 * Simple/cheap debounce implementation
  	 * @param   {function} fn - callback
  	 * @param   {number} delay - delay in seconds
  	 * @returns {function} debounced function
  	 */
  	function debounce(fn, delay) {
  	  var t
  	  return function () {
  	    clearTimeout(t)
  	    t = setTimeout(fn, delay)
  	  }
  	}
  
  	/**
  	 * Set the window listeners to trigger the routes
  	 * @param {boolean} autoExec - see route.start
  	 */
  	function start(autoExec) {
  	  debouncedEmit = debounce(emit, 1)
  	  win[ADD_EVENT_LISTENER](POPSTATE, debouncedEmit)
  	  win[ADD_EVENT_LISTENER](HASHCHANGE, debouncedEmit)
  	  doc[ADD_EVENT_LISTENER](clickEvent, click)
  	  if (autoExec) emit(true)
  	}
  
  	/**
  	 * Router class
  	 */
  	function Router() {
  	  this.$ = []
  	  riot.observable(this) // make it observable
  	  central.on('stop', this.s.bind(this))
  	  central.on('emit', this.e.bind(this))
  	}
  
  	function normalize(path) {
  	  return path[REPLACE](/^\/|\/$/, '')
  	}
  
  	function isString(str) {
  	  return typeof str == 'string'
  	}
  
  	/**
  	 * Get the part after domain name
  	 * @param {string} href - fullpath
  	 * @returns {string} path from root
  	 */
  	function getPathFromRoot(href) {
  	  return (href || loc.href)[REPLACE](RE_ORIGIN, '')
  	}
  
  	/**
  	 * Get the part after base
  	 * @param {string} href - fullpath
  	 * @returns {string} path from base
  	 */
  	function getPathFromBase(href) {
  	  return base[0] == '#'
  	    ? (href || loc.href || '').split(base)[1] || ''
  	    : (loc ? getPathFromRoot(href) : href || '')[REPLACE](base, '')
  	}
  
  	function emit(force) {
  	  // the stack is needed for redirections
  	  var isRoot = emitStackLevel == 0
  	  if (MAX_EMIT_STACK_LEVEL <= emitStackLevel) return
  
  	  emitStackLevel++
  	  emitStack.push(function() {
  	    var path = getPathFromBase()
  	    if (force || path != current) {
  	      central[TRIGGER]('emit', path)
  	      current = path
  	    }
  	  })
  	  if (isRoot) {
  	    while (emitStack.length) {
  	      emitStack[0]()
  	      emitStack.shift()
  	    }
  	    emitStackLevel = 0
  	  }
  	}
  
  	function click(e) {
  	  if (
  	    e.which != 1 // not left click
  	    || e.metaKey || e.ctrlKey || e.shiftKey // or meta keys
  	    || e.defaultPrevented // or default prevented
  	  ) return
  
  	  var el = e.target
  	  while (el && el.nodeName != 'A') el = el.parentNode
  
  	  if (
  	    !el || el.nodeName != 'A' // not A tag
  	    || el[HAS_ATTRIBUTE]('download') // has download attr
  	    || !el[HAS_ATTRIBUTE]('href') // has no href attr
  	    || el.target && el.target != '_self' // another window or frame
  	    || el.href.indexOf(loc.href.match(RE_ORIGIN)[0]) == -1 // cross origin
  	  ) return
  
  	  if (el.href != loc.href) {
  	    if (
  	      el.href.split('#')[0] == loc.href.split('#')[0] // internal jump
  	      || base != '#' && getPathFromRoot(el.href).indexOf(base) !== 0 // outside of base
  	      || !go(getPathFromBase(el.href), el.title || doc.title) // route not found
  	    ) return
  	  }
  
  	  e.preventDefault()
  	}
  
  	/**
  	 * Go to the path
  	 * @param {string} path - destination path
  	 * @param {string} title - page title
  	 * @param {boolean} shouldReplace - use replaceState or pushState
  	 * @returns {boolean} - route not found flag
  	 */
  	function go(path, title, shouldReplace) {
  	  if (hist) { // if a browser
  	    path = base + normalize(path)
  	    title = title || doc.title
  	    // browsers ignores the second parameter `title`
  	    shouldReplace
  	      ? hist.replaceState(null, title, path)
  	      : hist.pushState(null, title, path)
  	    // so we need to set it manually
  	    doc.title = title
  	    routeFound = false
  	    emit()
  	    return routeFound
  	  }
  
  	  // Server-side usage: directly execute handlers for the path
  	  return central[TRIGGER]('emit', getPathFromBase(path))
  	}
  
  	/**
  	 * Go to path or set action
  	 * a single string:                go there
  	 * two strings:                    go there with setting a title
  	 * two strings and boolean:        replace history with setting a title
  	 * a single function:              set an action on the default route
  	 * a string/RegExp and a function: set an action on the route
  	 * @param {(string|function)} first - path / action / filter
  	 * @param {(string|RegExp|function)} second - title / action
  	 * @param {boolean} third - replace flag
  	 */
  	prot.m = function(first, second, third) {
  	  if (isString(first) && (!second || isString(second))) go(first, second, third || false)
  	  else if (second) this.r(first, second)
  	  else this.r('@', first)
  	}
  
  	/**
  	 * Stop routing
  	 */
  	prot.s = function() {
  	  this.off('*')
  	  this.$ = []
  	}
  
  	/**
  	 * Emit
  	 * @param {string} path - path
  	 */
  	prot.e = function(path) {
  	  this.$.concat('@').some(function(filter) {
  	    var args = (filter == '@' ? parser : secondParser)(normalize(path), normalize(filter))
  	    if (typeof args != 'undefined') {
  	      this[TRIGGER].apply(null, [filter].concat(args))
  	      return routeFound = true // exit from loop
  	    }
  	  }, this)
  	}
  
  	/**
  	 * Register route
  	 * @param {string} filter - filter for matching to url
  	 * @param {function} action - action to register
  	 */
  	prot.r = function(filter, action) {
  	  if (filter != '@') {
  	    filter = '/' + normalize(filter)
  	    this.$.push(filter)
  	  }
  	  this.on(filter, action)
  	}
  
  	var mainRouter = new Router()
  	var route = mainRouter.m.bind(mainRouter)
  
  	/**
  	 * Create a sub router
  	 * @returns {function} the method of a new Router object
  	 */
  	route.create = function() {
  	  var newSubRouter = new Router()
  	  // assign sub-router's main method
  	  var router = newSubRouter.m.bind(newSubRouter)
  	  // stop only this sub-router
  	  router.stop = newSubRouter.s.bind(newSubRouter)
  	  return router
  	}
  
  	/**
  	 * Set the base of url
  	 * @param {(str|RegExp)} arg - a new base or '#' or '#!'
  	 */
  	route.base = function(arg) {
  	  base = arg || '#'
  	  current = getPathFromBase() // recalculate current path
  	}
  
  	/** Exec routing right now **/
  	route.exec = function() {
  	  emit(true)
  	}
  
  	/**
  	 * Replace the default router to yours
  	 * @param {function} fn - your parser function
  	 * @param {function} fn2 - your secondParser function
  	 */
  	route.parser = function(fn, fn2) {
  	  if (!fn && !fn2) {
  	    // reset parser for testing...
  	    parser = DEFAULT_PARSER
  	    secondParser = DEFAULT_SECOND_PARSER
  	  }
  	  if (fn) parser = fn
  	  if (fn2) secondParser = fn2
  	}
  
  	/**
  	 * Helper function to get url query as an object
  	 * @returns {object} parsed query
  	 */
  	route.query = function() {
  	  var q = {}
  	  var href = loc.href || current
  	  href[REPLACE](/[?&](.+?)=([^&]*)/g, function(_, k, v) { q[k] = v })
  	  return q
  	}
  
  	/** Stop routing **/
  	route.stop = function () {
  	  if (started) {
  	    if (win) {
  	      win[REMOVE_EVENT_LISTENER](POPSTATE, debouncedEmit)
  	      win[REMOVE_EVENT_LISTENER](HASHCHANGE, debouncedEmit)
  	      doc[REMOVE_EVENT_LISTENER](clickEvent, click)
  	    }
  	    central[TRIGGER]('stop')
  	    started = false
  	  }
  	}
  
  	/**
  	 * Start routing
  	 * @param {boolean} autoExec - automatically exec after starting if true
  	 */
  	route.start = function (autoExec) {
  	  if (!started) {
  	    if (win) {
  	      if (document.readyState == 'complete') start(autoExec)
  	      // the timeout is needed to solve
  	      // a weird safari bug https://github.com/riot/route/issues/33
  	      else win[ADD_EVENT_LISTENER]('load', function() {
  	        setTimeout(function() { start(autoExec) }, 1)
  	      })
  	    }
  	    started = true
  	  }
  	}
  
  	/** Prepare the router **/
  	route.base()
  	route.parser()
  
  	riot.route = route
  	})(riot)
  	/* istanbul ignore next */
  
  	/**
  	 * The riot template engine
  	 * @version v2.4.0
  	 */
  	/**
  	 * riot.util.brackets
  	 *
  	 * - `brackets    ` - Returns a string or regex based on its parameter
  	 * - `brackets.set` - Change the current riot brackets
  	 *
  	 * @module
  	 */
  
  	var brackets = (function (UNDEF) {
  
  	  var
  	    REGLOB = 'g',
  
  	    R_MLCOMMS = /\/\*[^*]*\*+(?:[^*\/][^*]*\*+)*\//g,
  
  	    R_STRINGS = /"[^"\\]*(?:\\[\S\s][^"\\]*)*"|'[^'\\]*(?:\\[\S\s][^'\\]*)*'/g,
  
  	    S_QBLOCKS = R_STRINGS.source + '|' +
  	      /(?:\breturn\s+|(?:[$\w\)\]]|\+\+|--)\s*(\/)(?![*\/]))/.source + '|' +
  	      /\/(?=[^*\/])[^[\/\\]*(?:(?:\[(?:\\.|[^\]\\]*)*\]|\\.)[^[\/\\]*)*?(\/)[gim]*/.source,
  
  	    FINDBRACES = {
  	      '(': RegExp('([()])|'   + S_QBLOCKS, REGLOB),
  	      '[': RegExp('([[\\]])|' + S_QBLOCKS, REGLOB),
  	      '{': RegExp('([{}])|'   + S_QBLOCKS, REGLOB)
  	    },
  
  	    DEFAULT = '{ }'
  
  	  var _pairs = [
  	    '{', '}',
  	    '{', '}',
  	    /{[^}]*}/,
  	    /\\([{}])/g,
  	    /\\({)|{/g,
  	    RegExp('\\\\(})|([[({])|(})|' + S_QBLOCKS, REGLOB),
  	    DEFAULT,
  	    /^\s*{\^?\s*([$\w]+)(?:\s*,\s*(\S+))?\s+in\s+(\S.*)\s*}/,
  	    /(^|[^\\]){=[\S\s]*?}/
  	  ]
  
  	  var
  	    cachedBrackets = UNDEF,
  	    _regex,
  	    _cache = [],
  	    _settings
  
  	  function _loopback (re) { return re }
  
  	  function _rewrite (re, bp) {
  	    if (!bp) bp = _cache
  	    return new RegExp(
  	      re.source.replace(/{/g, bp[2]).replace(/}/g, bp[3]), re.global ? REGLOB : ''
  	    )
  	  }
  
  	  function _create (pair) {
  	    if (pair === DEFAULT) return _pairs
  
  	    var arr = pair.split(' ')
  
  	    if (arr.length !== 2 || /[\x00-\x1F<>a-zA-Z0-9'",;\\]/.test(pair)) { // eslint-disable-line
  	      throw new Error('Unsupported brackets "' + pair + '"')
  	    }
  	    arr = arr.concat(pair.replace(/(?=[[\]()*+?.^$|])/g, '\\').split(' '))
  
  	    arr[4] = _rewrite(arr[1].length > 1 ? /{[\S\s]*?}/ : _pairs[4], arr)
  	    arr[5] = _rewrite(pair.length > 3 ? /\\({|})/g : _pairs[5], arr)
  	    arr[6] = _rewrite(_pairs[6], arr)
  	    arr[7] = RegExp('\\\\(' + arr[3] + ')|([[({])|(' + arr[3] + ')|' + S_QBLOCKS, REGLOB)
  	    arr[8] = pair
  	    return arr
  	  }
  
  	  function _brackets (reOrIdx) {
  	    return reOrIdx instanceof RegExp ? _regex(reOrIdx) : _cache[reOrIdx]
  	  }
  
  	  _brackets.split = function split (str, tmpl, _bp) {
  	    // istanbul ignore next: _bp is for the compiler
  	    if (!_bp) _bp = _cache
  
  	    var
  	      parts = [],
  	      match,
  	      isexpr,
  	      start,
  	      pos,
  	      re = _bp[6]
  
  	    isexpr = start = re.lastIndex = 0
  
  	    while ((match = re.exec(str))) {
  
  	      pos = match.index
  
  	      if (isexpr) {
  
  	        if (match[2]) {
  	          re.lastIndex = skipBraces(str, match[2], re.lastIndex)
  	          continue
  	        }
  	        if (!match[3]) {
  	          continue
  	        }
  	      }
  
  	      if (!match[1]) {
  	        unescapeStr(str.slice(start, pos))
  	        start = re.lastIndex
  	        re = _bp[6 + (isexpr ^= 1)]
  	        re.lastIndex = start
  	      }
  	    }
  
  	    if (str && start < str.length) {
  	      unescapeStr(str.slice(start))
  	    }
  
  	    return parts
  
  	    function unescapeStr (s) {
  	      if (tmpl || isexpr) {
  	        parts.push(s && s.replace(_bp[5], '$1'))
  	      } else {
  	        parts.push(s)
  	      }
  	    }
  
  	    function skipBraces (s, ch, ix) {
  	      var
  	        match,
  	        recch = FINDBRACES[ch]
  
  	      recch.lastIndex = ix
  	      ix = 1
  	      while ((match = recch.exec(s))) {
  	        if (match[1] &&
  	          !(match[1] === ch ? ++ix : --ix)) break
  	      }
  	      return ix ? s.length : recch.lastIndex
  	    }
  	  }
  
  	  _brackets.hasExpr = function hasExpr (str) {
  	    return _cache[4].test(str)
  	  }
  
  	  _brackets.loopKeys = function loopKeys (expr) {
  	    var m = expr.match(_cache[9])
  
  	    return m
  	      ? { key: m[1], pos: m[2], val: _cache[0] + m[3].trim() + _cache[1] }
  	      : { val: expr.trim() }
  	  }
  
  	  _brackets.array = function array (pair) {
  	    return pair ? _create(pair) : _cache
  	  }
  
  	  function _reset (pair) {
  	    if ((pair || (pair = DEFAULT)) !== _cache[8]) {
  	      _cache = _create(pair)
  	      _regex = pair === DEFAULT ? _loopback : _rewrite
  	      _cache[9] = _regex(_pairs[9])
  	    }
  	    cachedBrackets = pair
  	  }
  
  	  function _setSettings (o) {
  	    var b
  
  	    o = o || {}
  	    b = o.brackets
  	    Object.defineProperty(o, 'brackets', {
  	      set: _reset,
  	      get: function () { return cachedBrackets },
  	      enumerable: true
  	    })
  	    _settings = o
  	    _reset(b)
  	  }
  
  	  Object.defineProperty(_brackets, 'settings', {
  	    set: _setSettings,
  	    get: function () { return _settings }
  	  })
  
  	  /* istanbul ignore next: in the browser riot is always in the scope */
  	  _brackets.settings = typeof riot !== 'undefined' && riot.settings || {}
  	  _brackets.set = _reset
  
  	  _brackets.R_STRINGS = R_STRINGS
  	  _brackets.R_MLCOMMS = R_MLCOMMS
  	  _brackets.S_QBLOCKS = S_QBLOCKS
  
  	  return _brackets
  
  	})()
  
  	/**
  	 * @module tmpl
  	 *
  	 * tmpl          - Root function, returns the template value, render with data
  	 * tmpl.hasExpr  - Test the existence of a expression inside a string
  	 * tmpl.loopKeys - Get the keys for an 'each' loop (used by `_each`)
  	 */
  
  	var tmpl = (function () {
  
  	  var _cache = {}
  
  	  function _tmpl (str, data) {
  	    if (!str) return str
  
  	    return (_cache[str] || (_cache[str] = _create(str))).call(data, _logErr)
  	  }
  
  	  _tmpl.haveRaw = brackets.hasRaw
  
  	  _tmpl.hasExpr = brackets.hasExpr
  
  	  _tmpl.loopKeys = brackets.loopKeys
  
  	  _tmpl.errorHandler = null
  
  	  function _logErr (err, ctx) {
  
  	    if (_tmpl.errorHandler) {
  
  	      err.riotData = {
  	        tagName: ctx && ctx.root && ctx.root.tagName,
  	        _riot_id: ctx && ctx._riot_id  //eslint-disable-line camelcase
  	      }
  	      _tmpl.errorHandler(err)
  	    }
  	  }
  
  	  function _create (str) {
  	    var expr = _getTmpl(str)
  
  	    if (expr.slice(0, 11) !== 'try{return ') expr = 'return ' + expr
  
  	/* eslint-disable */
  
  	    return new Function('E', expr + ';')
  	/* eslint-enable */
  	  }
  
  	  var
  	    CH_IDEXPR = '\u2057',
  	    RE_CSNAME = /^(?:(-?[_A-Za-z\xA0-\xFF][-\w\xA0-\xFF]*)|\u2057(\d+)~):/,
  	    RE_QBLOCK = RegExp(brackets.S_QBLOCKS, 'g'),
  	    RE_DQUOTE = /\u2057/g,
  	    RE_QBMARK = /\u2057(\d+)~/g
  
  	  function _getTmpl (str) {
  	    var
  	      qstr = [],
  	      expr,
  	      parts = brackets.split(str.replace(RE_DQUOTE, '"'), 1)
  
  	    if (parts.length > 2 || parts[0]) {
  	      var i, j, list = []
  
  	      for (i = j = 0; i < parts.length; ++i) {
  
  	        expr = parts[i]
  
  	        if (expr && (expr = i & 1
  
  	            ? _parseExpr(expr, 1, qstr)
  
  	            : '"' + expr
  	                .replace(/\\/g, '\\\\')
  	                .replace(/\r\n?|\n/g, '\\n')
  	                .replace(/"/g, '\\"') +
  	              '"'
  
  	          )) list[j++] = expr
  
  	      }
  
  	      expr = j < 2 ? list[0]
  	           : '[' + list.join(',') + '].join("")'
  
  	    } else {
  
  	      expr = _parseExpr(parts[1], 0, qstr)
  	    }
  
  	    if (qstr[0]) {
  	      expr = expr.replace(RE_QBMARK, function (_, pos) {
  	        return qstr[pos]
  	          .replace(/\r/g, '\\r')
  	          .replace(/\n/g, '\\n')
  	      })
  	    }
  	    return expr
  	  }
  
  	  var
  	    RE_BREND = {
  	      '(': /[()]/g,
  	      '[': /[[\]]/g,
  	      '{': /[{}]/g
  	    }
  
  	  function _parseExpr (expr, asText, qstr) {
  
  	    expr = expr
  	          .replace(RE_QBLOCK, function (s, div) {
  	            return s.length > 2 && !div ? CH_IDEXPR + (qstr.push(s) - 1) + '~' : s
  	          })
  	          .replace(/\s+/g, ' ').trim()
  	          .replace(/\ ?([[\({},?\.:])\ ?/g, '$1')
  
  	    if (expr) {
  	      var
  	        list = [],
  	        cnt = 0,
  	        match
  
  	      while (expr &&
  	            (match = expr.match(RE_CSNAME)) &&
  	            !match.index
  	        ) {
  	        var
  	          key,
  	          jsb,
  	          re = /,|([[{(])|$/g
  
  	        expr = RegExp.rightContext
  	        key  = match[2] ? qstr[match[2]].slice(1, -1).trim().replace(/\s+/g, ' ') : match[1]
  
  	        while (jsb = (match = re.exec(expr))[1]) skipBraces(jsb, re)
  
  	        jsb  = expr.slice(0, match.index)
  	        expr = RegExp.rightContext
  
  	        list[cnt++] = _wrapExpr(jsb, 1, key)
  	      }
  
  	      expr = !cnt ? _wrapExpr(expr, asText)
  	           : cnt > 1 ? '[' + list.join(',') + '].join(" ").trim()' : list[0]
  	    }
  	    return expr
  
  	    function skipBraces (ch, re) {
  	      var
  	        mm,
  	        lv = 1,
  	        ir = RE_BREND[ch]
  
  	      ir.lastIndex = re.lastIndex
  	      while (mm = ir.exec(expr)) {
  	        if (mm[0] === ch) ++lv
  	        else if (!--lv) break
  	      }
  	      re.lastIndex = lv ? expr.length : ir.lastIndex
  	    }
  	  }
  
  	  // istanbul ignore next: not both
  	  var // eslint-disable-next-line max-len
  	    JS_CONTEXT = '"in this?this:' + (typeof window !== 'object' ? 'global' : 'window') + ').',
  	    JS_VARNAME = /[,{][$\w]+:|(^ *|[^$\w\.])(?!(?:typeof|true|false|null|undefined|in|instanceof|is(?:Finite|NaN)|void|NaN|new|Date|RegExp|Math)(?![$\w]))([$_A-Za-z][$\w]*)/g,
  	    JS_NOPROPS = /^(?=(\.[$\w]+))\1(?:[^.[(]|$)/
  
  	  function _wrapExpr (expr, asText, key) {
  	    var tb
  
  	    expr = expr.replace(JS_VARNAME, function (match, p, mvar, pos, s) {
  	      if (mvar) {
  	        pos = tb ? 0 : pos + match.length
  
  	        if (mvar !== 'this' && mvar !== 'global' && mvar !== 'window') {
  	          match = p + '("' + mvar + JS_CONTEXT + mvar
  	          if (pos) tb = (s = s[pos]) === '.' || s === '(' || s === '['
  	        } else if (pos) {
  	          tb = !JS_NOPROPS.test(s.slice(pos))
  	        }
  	      }
  	      return match
  	    })
  
  	    if (tb) {
  	      expr = 'try{return ' + expr + '}catch(e){E(e,this)}'
  	    }
  
  	    if (key) {
  
  	      expr = (tb
  	          ? 'function(){' + expr + '}.call(this)' : '(' + expr + ')'
  	        ) + '?"' + key + '":""'
  
  	    } else if (asText) {
  
  	      expr = 'function(v){' + (tb
  	          ? expr.replace('return ', 'v=') : 'v=(' + expr + ')'
  	        ) + ';return v||v===0?v:""}.call(this)'
  	    }
  
  	    return expr
  	  }
  
  	  // istanbul ignore next: compatibility fix for beta versions
  	  _tmpl.parse = function (s) { return s }
  
  	  _tmpl.version = brackets.version = 'v2.4.0'
  
  	  return _tmpl
  
  	})()
  
  	/*
  	  lib/browser/tag/mkdom.js
  
  	  Includes hacks needed for the Internet Explorer version 9 and below
  	  See: http://kangax.github.io/compat-table/es5/#ie8
  	       http://codeplanet.io/dropping-ie8/
  	*/
  	var mkdom = (function _mkdom() {
  	  var
  	    reHasYield  = /<yield\b/i,
  	    reYieldAll  = /<yield\s*(?:\/>|>([\S\s]*?)<\/yield\s*>|>)/ig,
  	    reYieldSrc  = /<yield\s+to=['"]([^'">]*)['"]\s*>([\S\s]*?)<\/yield\s*>/ig,
  	    reYieldDest = /<yield\s+from=['"]?([-\w]+)['"]?\s*(?:\/>|>([\S\s]*?)<\/yield\s*>)/ig
  	  var
  	    rootEls = { tr: 'tbody', th: 'tr', td: 'tr', col: 'colgroup' },
  	    tblTags = IE_VERSION && IE_VERSION < 10
  	      ? SPECIAL_TAGS_REGEX : /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?)$/
  
  	  /**
  	   * Creates a DOM element to wrap the given content. Normally an `DIV`, but can be
  	   * also a `TABLE`, `SELECT`, `TBODY`, `TR`, or `COLGROUP` element.
  	   *
  	   * @param   {string} templ  - The template coming from the custom tag definition
  	   * @param   {string} [html] - HTML content that comes from the DOM element where you
  	   *           will mount the tag, mostly the original tag in the page
  	   * @returns {HTMLElement} DOM element with _templ_ merged through `YIELD` with the _html_.
  	   */
  	  function _mkdom(templ, html) {
  	    var
  	      match   = templ && templ.match(/^\s*<([-\w]+)/),
  	      tagName = match && match[1].toLowerCase(),
  	      el = mkEl('div', isSVGTag(tagName))
  
  	    // replace all the yield tags with the tag inner html
  	    templ = replaceYield(templ, html)
  
  	    /* istanbul ignore next */
  	    if (tblTags.test(tagName))
  	      el = specialTags(el, templ, tagName)
  	    else
  	      setInnerHTML(el, templ)
  
  	    el.stub = true
  
  	    return el
  	  }
  
  	  /*
  	    Creates the root element for table or select child elements:
  	    tr/th/td/thead/tfoot/tbody/caption/col/colgroup/option/optgroup
  	  */
  	  function specialTags(el, templ, tagName) {
  	    var
  	      select = tagName[0] === 'o',
  	      parent = select ? 'select>' : 'table>'
  
  	    // trim() is important here, this ensures we don't have artifacts,
  	    // so we can check if we have only one element inside the parent
  	    el.innerHTML = '<' + parent + templ.trim() + '</' + parent
  	    parent = el.firstChild
  
  	    // returns the immediate parent if tr/th/td/col is the only element, if not
  	    // returns the whole tree, as this can include additional elements
  	    if (select) {
  	      parent.selectedIndex = -1  // for IE9, compatible w/current riot behavior
  	    } else {
  	      // avoids insertion of cointainer inside container (ex: tbody inside tbody)
  	      var tname = rootEls[tagName]
  	      if (tname && parent.childElementCount === 1) parent = $(tname, parent)
  	    }
  	    return parent
  	  }
  
  	  /*
  	    Replace the yield tag from any tag template with the innerHTML of the
  	    original tag in the page
  	  */
  	  function replaceYield(templ, html) {
  	    // do nothing if no yield
  	    if (!reHasYield.test(templ)) return templ
  
  	    // be careful with #1343 - string on the source having `$1`
  	    var src = {}
  
  	    html = html && html.replace(reYieldSrc, function (_, ref, text) {
  	      src[ref] = src[ref] || text   // preserve first definition
  	      return ''
  	    }).trim()
  
  	    return templ
  	      .replace(reYieldDest, function (_, ref, def) {  // yield with from - to attrs
  	        return src[ref] || def || ''
  	      })
  	      .replace(reYieldAll, function (_, def) {        // yield without any "from"
  	        return html || def || ''
  	      })
  	  }
  
  	  return _mkdom
  
  	})()
  
  	/**
  	 * Convert the item looped into an object used to extend the child tag properties
  	 * @param   { Object } expr - object containing the keys used to extend the children tags
  	 * @param   { * } key - value to assign to the new object returned
  	 * @param   { * } val - value containing the position of the item in the array
  	 * @returns { Object } - new object containing the values of the original item
  	 *
  	 * The variables 'key' and 'val' are arbitrary.
  	 * They depend on the collection type looped (Array, Object)
  	 * and on the expression used on the each tag
  	 *
  	 */
  	function mkitem(expr, key, val) {
  	  var item = {}
  	  item[expr.key] = key
  	  if (expr.pos) item[expr.pos] = val
  	  return item
  	}
  
  	/**
  	 * Unmount the redundant tags
  	 * @param   { Array } items - array containing the current items to loop
  	 * @param   { Array } tags - array containing all the children tags
  	 */
  	function unmountRedundant(items, tags) {
  
  	  var i = tags.length,
  	    j = items.length,
  	    t
  
  	  while (i > j) {
  	    t = tags[--i]
  	    tags.splice(i, 1)
  	    t.unmount()
  	  }
  	}
  
  	/**
  	 * Move the nested custom tags in non custom loop tags
  	 * @param   { Object } child - non custom loop tag
  	 * @param   { Number } i - current position of the loop tag
  	 */
  	function moveNestedTags(child, i) {
  	  Object.keys(child.tags).forEach(function(tagName) {
  	    var tag = child.tags[tagName]
  	    if (isArray(tag))
  	      each(tag, function (t) {
  	        moveChildTag(t, tagName, i)
  	      })
  	    else
  	      moveChildTag(tag, tagName, i)
  	  })
  	}
  
  	/**
  	 * Adds the elements for a virtual tag
  	 * @param { Tag } tag - the tag whose root's children will be inserted or appended
  	 * @param { Node } src - the node that will do the inserting or appending
  	 * @param { Tag } target - only if inserting, insert before this tag's first child
  	 */
  	function addVirtual(tag, src, target) {
  	  var el = tag._root, sib
  	  tag._virts = []
  	  while (el) {
  	    sib = el.nextSibling
  	    if (target)
  	      src.insertBefore(el, target._root)
  	    else
  	      src.appendChild(el)
  
  	    tag._virts.push(el) // hold for unmounting
  	    el = sib
  	  }
  	}
  
  	/**
  	 * Move virtual tag and all child nodes
  	 * @param { Tag } tag - first child reference used to start move
  	 * @param { Node } src  - the node that will do the inserting
  	 * @param { Tag } target - insert before this tag's first child
  	 * @param { Number } len - how many child nodes to move
  	 */
  	function moveVirtual(tag, src, target, len) {
  	  var el = tag._root, sib, i = 0
  	  for (; i < len; i++) {
  	    sib = el.nextSibling
  	    src.insertBefore(el, target._root)
  	    el = sib
  	  }
  	}
  
  
  	/**
  	 * Manage tags having the 'each'
  	 * @param   { Object } dom - DOM node we need to loop
  	 * @param   { Tag } parent - parent tag instance where the dom node is contained
  	 * @param   { String } expr - string contained in the 'each' attribute
  	 */
  	function _each(dom, parent, expr) {
  
  	  // remove the each property from the original tag
  	  remAttr(dom, 'each')
  
  	  var mustReorder = typeof getAttr(dom, 'no-reorder') !== T_STRING || remAttr(dom, 'no-reorder'),
  	    tagName = getTagName(dom),
  	    impl = __tagImpl[tagName] || { tmpl: getOuterHTML(dom) },
  	    useRoot = SPECIAL_TAGS_REGEX.test(tagName),
  	    root = dom.parentNode,
  	    ref = document.createTextNode(''),
  	    child = getTag(dom),
  	    isOption = tagName.toLowerCase() === 'option', // the option tags must be treated differently
  	    tags = [],
  	    oldItems = [],
  	    hasKeys,
  	    isVirtual = dom.tagName == 'VIRTUAL'
  
  	  // parse the each expression
  	  expr = tmpl.loopKeys(expr)
  
  	  // insert a marked where the loop tags will be injected
  	  root.insertBefore(ref, dom)
  
  	  // clean template code
  	  parent.one('before-mount', function () {
  
  	    // remove the original DOM node
  	    dom.parentNode.removeChild(dom)
  	    if (root.stub) root = parent.root
  
  	  }).on('update', function () {
  	    // get the new items collection
  	    var items = tmpl(expr.val, parent),
  	      // create a fragment to hold the new DOM nodes to inject in the parent tag
  	      frag = document.createDocumentFragment()
  
  	    // object loop. any changes cause full redraw
  	    if (!isArray(items)) {
  	      hasKeys = items || false
  	      items = hasKeys ?
  	        Object.keys(items).map(function (key) {
  	          return mkitem(expr, key, items[key])
  	        }) : []
  	    }
  
  	    // loop all the new items
  	    var i = 0,
  	      itemsLength = items.length
  
  	    for (; i < itemsLength; i++) {
  	      // reorder only if the items are objects
  	      var
  	        item = items[i],
  	        _mustReorder = mustReorder && typeof item == T_OBJECT && !hasKeys,
  	        oldPos = oldItems.indexOf(item),
  	        pos = ~oldPos && _mustReorder ? oldPos : i,
  	        // does a tag exist in this position?
  	        tag = tags[pos]
  
  	      item = !hasKeys && expr.key ? mkitem(expr, item, i) : item
  
  	      // new tag
  	      if (
  	        !_mustReorder && !tag // with no-reorder we just update the old tags
  	        ||
  	        _mustReorder && !~oldPos || !tag // by default we always try to reorder the DOM elements
  	      ) {
  
  	        tag = new Tag(impl, {
  	          parent: parent,
  	          isLoop: true,
  	          hasImpl: !!__tagImpl[tagName],
  	          root: useRoot ? root : dom.cloneNode(),
  	          item: item
  	        }, dom.innerHTML)
  
  	        tag.mount()
  
  	        if (isVirtual) tag._root = tag.root.firstChild // save reference for further moves or inserts
  	        // this tag must be appended
  	        if (i == tags.length || !tags[i]) { // fix 1581
  	          if (isVirtual)
  	            addVirtual(tag, frag)
  	          else frag.appendChild(tag.root)
  	        }
  	        // this tag must be insert
  	        else {
  	          if (isVirtual)
  	            addVirtual(tag, root, tags[i])
  	          else root.insertBefore(tag.root, tags[i].root) // #1374 some browsers reset selected here
  	          oldItems.splice(i, 0, item)
  	        }
  
  	        tags.splice(i, 0, tag)
  	        pos = i // handled here so no move
  	      } else tag.update(item, true)
  
  	      // reorder the tag if it's not located in its previous position
  	      if (
  	        pos !== i && _mustReorder &&
  	        tags[i] // fix 1581 unable to reproduce it in a test!
  	      ) {
  	        // update the DOM
  	        if (isVirtual)
  	          moveVirtual(tag, root, tags[i], dom.childNodes.length)
  	        else root.insertBefore(tag.root, tags[i].root)
  	        // update the position attribute if it exists
  	        if (expr.pos)
  	          tag[expr.pos] = i
  	        // move the old tag instance
  	        tags.splice(i, 0, tags.splice(pos, 1)[0])
  	        // move the old item
  	        oldItems.splice(i, 0, oldItems.splice(pos, 1)[0])
  	        // if the loop tags are not custom
  	        // we need to move all their custom tags into the right position
  	        if (!child && tag.tags) moveNestedTags(tag, i)
  	      }
  
  	      // cache the original item to use it in the events bound to this node
  	      // and its children
  	      tag._item = item
  	      // cache the real parent tag internally
  	      defineProperty(tag, '_parent', parent)
  	    }
  
  	    // remove the redundant tags
  	    unmountRedundant(items, tags)
  
  	    // insert the new nodes
  	    if (isOption) {
  	      root.appendChild(frag)
  
  	      // #1374 FireFox bug in <option selected={expression}>
  	      if (FIREFOX && !root.multiple) {
  	        for (var n = 0; n < root.length; n++) {
  	          if (root[n].__riot1374) {
  	            root.selectedIndex = n  // clear other options
  	            delete root[n].__riot1374
  	            break
  	          }
  	        }
  	      }
  	    }
  	    else root.insertBefore(frag, ref)
  
  	    // set the 'tags' property of the parent tag
  	    // if child is 'undefined' it means that we don't need to set this property
  	    // for example:
  	    // we don't need store the `myTag.tags['div']` property if we are looping a div tag
  	    // but we need to track the `myTag.tags['child']` property looping a custom child node named `child`
  	    if (child) parent.tags[tagName] = tags
  
  	    // clone the items array
  	    oldItems = items.slice()
  
  	  })
  
  	}
  	/**
  	 * Object that will be used to inject and manage the css of every tag instance
  	 */
  	var styleManager = (function(_riot) {
  
  	  if (!window) return { // skip injection on the server
  	    add: function () {},
  	    inject: function () {}
  	  }
  
  	  var styleNode = (function () {
  	    // create a new style element with the correct type
  	    var newNode = mkEl('style')
  	    setAttr(newNode, 'type', 'text/css')
  
  	    // replace any user node or insert the new one into the head
  	    var userNode = $('style[type=riot]')
  	    if (userNode) {
  	      if (userNode.id) newNode.id = userNode.id
  	      userNode.parentNode.replaceChild(newNode, userNode)
  	    }
  	    else document.getElementsByTagName('head')[0].appendChild(newNode)
  
  	    return newNode
  	  })()
  
  	  // Create cache and shortcut to the correct property
  	  var cssTextProp = styleNode.styleSheet,
  	    stylesToInject = ''
  
  	  // Expose the style node in a non-modificable property
  	  Object.defineProperty(_riot, 'styleNode', {
  	    value: styleNode,
  	    writable: true
  	  })
  
  	  /**
  	   * Public api
  	   */
  	  return {
  	    /**
  	     * Save a tag style to be later injected into DOM
  	     * @param   { String } css [description]
  	     */
  	    add: function(css) {
  	      stylesToInject += css
  	    },
  	    /**
  	     * Inject all previously saved tag styles into DOM
  	     * innerHTML seems slow: http://jsperf.com/riot-insert-style
  	     */
  	    inject: function() {
  	      if (stylesToInject) {
  	        if (cssTextProp) cssTextProp.cssText += stylesToInject
  	        else styleNode.innerHTML += stylesToInject
  	        stylesToInject = ''
  	      }
  	    }
  	  }
  
  	})(riot)
  
  
  	function parseNamedElements(root, tag, childTags, forceParsingNamed) {
  
  	  walk(root, function(dom) {
  	    if (dom.nodeType == 1) {
  	      dom.isLoop = dom.isLoop ||
  	                  (dom.parentNode && dom.parentNode.isLoop || getAttr(dom, 'each'))
  	                    ? 1 : 0
  
  	      // custom child tag
  	      if (childTags) {
  	        var child = getTag(dom)
  
  	        if (child && !dom.isLoop)
  	          childTags.push(initChildTag(child, {root: dom, parent: tag}, dom.innerHTML, tag))
  	      }
  
  	      if (!dom.isLoop || forceParsingNamed)
  	        setNamed(dom, tag, [])
  	    }
  
  	  })
  
  	}
  
  	function parseExpressions(root, tag, expressions) {
  
  	  function addExpr(dom, val, extra) {
  	    if (tmpl.hasExpr(val)) {
  	      expressions.push(extend({ dom: dom, expr: val }, extra))
  	    }
  	  }
  
  	  walk(root, function(dom) {
  	    var type = dom.nodeType,
  	      attr
  
  	    // text node
  	    if (type == 3 && dom.parentNode.tagName != 'STYLE') addExpr(dom, dom.nodeValue)
  	    if (type != 1) return
  
  	    /* element */
  
  	    // loop
  	    attr = getAttr(dom, 'each')
  
  	    if (attr) { _each(dom, tag, attr); return false }
  
  	    // attribute expressions
  	    each(dom.attributes, function(attr) {
  	      var name = attr.name,
  	        bool = name.split('__')[1]
  
  	      addExpr(dom, attr.value, { attr: bool || name, bool: bool })
  	      if (bool) { remAttr(dom, name); return false }
  
  	    })
  
  	    // skip custom tags
  	    if (getTag(dom)) return false
  
  	  })
  
  	}
  	function Tag(impl, conf, innerHTML) {
  
  	  var self = riot.observable(this),
  	    opts = inherit(conf.opts) || {},
  	    parent = conf.parent,
  	    isLoop = conf.isLoop,
  	    hasImpl = conf.hasImpl,
  	    item = cleanUpData(conf.item),
  	    expressions = [],
  	    childTags = [],
  	    root = conf.root,
  	    tagName = root.tagName.toLowerCase(),
  	    attr = {},
  	    propsInSyncWithParent = [],
  	    dom
  
  	  // only call unmount if we have a valid __tagImpl (has name property)
  	  if (impl.name && root._tag) root._tag.unmount(true)
  
  	  // not yet mounted
  	  this.isMounted = false
  	  root.isLoop = isLoop
  
  	  // keep a reference to the tag just created
  	  // so we will be able to mount this tag multiple times
  	  root._tag = this
  
  	  // create a unique id to this tag
  	  // it could be handy to use it also to improve the virtual dom rendering speed
  	  defineProperty(this, '_riot_id', ++__uid) // base 1 allows test !t._riot_id
  
  	  extend(this, { parent: parent, root: root, opts: opts}, item)
  	  // protect the "tags" property from being overridden
  	  defineProperty(this, 'tags', {})
  
  	  // grab attributes
  	  each(root.attributes, function(el) {
  	    var val = el.value
  	    // remember attributes with expressions only
  	    if (tmpl.hasExpr(val)) attr[el.name] = val
  	  })
  
  	  dom = mkdom(impl.tmpl, innerHTML)
  
  	  // options
  	  function updateOpts() {
  	    var ctx = hasImpl && isLoop ? self : parent || self
  
  	    // update opts from current DOM attributes
  	    each(root.attributes, function(el) {
  	      var val = el.value
  	      opts[toCamel(el.name)] = tmpl.hasExpr(val) ? tmpl(val, ctx) : val
  	    })
  	    // recover those with expressions
  	    each(Object.keys(attr), function(name) {
  	      opts[toCamel(name)] = tmpl(attr[name], ctx)
  	    })
  	  }
  
  	  function normalizeData(data) {
  	    for (var key in item) {
  	      if (typeof self[key] !== T_UNDEF && isWritable(self, key))
  	        self[key] = data[key]
  	    }
  	  }
  
  	  function inheritFromParent () {
  	    if (!self.parent || !isLoop) return
  	    each(Object.keys(self.parent), function(k) {
  	      // some properties must be always in sync with the parent tag
  	      var mustSync = !RESERVED_WORDS_BLACKLIST.test(k) && contains(propsInSyncWithParent, k)
  	      if (typeof self[k] === T_UNDEF || mustSync) {
  	        // track the property to keep in sync
  	        // so we can keep it updated
  	        if (!mustSync) propsInSyncWithParent.push(k)
  	        self[k] = self.parent[k]
  	      }
  	    })
  	  }
  
  	  /**
  	   * Update the tag expressions and options
  	   * @param   { * }  data - data we want to use to extend the tag properties
  	   * @param   { Boolean } isInherited - is this update coming from a parent tag?
  	   * @returns { self }
  	   */
  	  defineProperty(this, 'update', function(data, isInherited) {
  
  	    // make sure the data passed will not override
  	    // the component core methods
  	    data = cleanUpData(data)
  	    // inherit properties from the parent
  	    inheritFromParent()
  	    // normalize the tag properties in case an item object was initially passed
  	    if (data && isObject(item)) {
  	      normalizeData(data)
  	      item = data
  	    }
  	    extend(self, data)
  	    updateOpts()
  	    self.trigger('update', data)
  	    update(expressions, self)
  
  	    // the updated event will be triggered
  	    // once the DOM will be ready and all the re-flows are completed
  	    // this is useful if you want to get the "real" root properties
  	    // 4 ex: root.offsetWidth ...
  	    if (isInherited && self.parent)
  	      // closes #1599
  	      self.parent.one('updated', function() { self.trigger('updated') })
  	    else rAF(function() { self.trigger('updated') })
  
  	    return this
  	  })
  
  	  defineProperty(this, 'mixin', function() {
  	    each(arguments, function(mix) {
  	      var instance
  
  	      mix = typeof mix === T_STRING ? riot.mixin(mix) : mix
  
  	      // check if the mixin is a function
  	      if (isFunction(mix)) {
  	        // create the new mixin instance
  	        instance = new mix()
  	        // save the prototype to loop it afterwards
  	        mix = mix.prototype
  	      } else instance = mix
  
  	      // loop the keys in the function prototype or the all object keys
  	      each(Object.getOwnPropertyNames(mix), function(key) {
  	        // bind methods to self
  	        if (key != 'init')
  	          self[key] = isFunction(instance[key]) ?
  	                        instance[key].bind(self) :
  	                        instance[key]
  	      })
  
  	      // init method will be called automatically
  	      if (instance.init) instance.init.bind(self)()
  	    })
  	    return this
  	  })
  
  	  defineProperty(this, 'mount', function() {
  
  	    updateOpts()
  
  	    // add global mixins
  	    var globalMixin = riot.mixin(GLOBAL_MIXIN)
  	    if (globalMixin)
  	      for (var i in globalMixin)
  	        if (globalMixin.hasOwnProperty(i))
  	          self.mixin(globalMixin[i])
  
  	    // initialiation
  	    if (impl.fn) impl.fn.call(self, opts)
  
  	    // parse layout after init. fn may calculate args for nested custom tags
  	    parseExpressions(dom, self, expressions)
  
  	    // mount the child tags
  	    toggle(true)
  
  	    // update the root adding custom attributes coming from the compiler
  	    // it fixes also #1087
  	    if (impl.attrs)
  	      walkAttributes(impl.attrs, function (k, v) { setAttr(root, k, v) })
  	    if (impl.attrs || hasImpl)
  	      parseExpressions(self.root, self, expressions)
  
  	    if (!self.parent || isLoop) self.update(item)
  
  	    // internal use only, fixes #403
  	    self.trigger('before-mount')
  
  	    if (isLoop && !hasImpl) {
  	      // update the root attribute for the looped elements
  	      root = dom.firstChild
  	    } else {
  	      while (dom.firstChild) root.appendChild(dom.firstChild)
  	      if (root.stub) root = parent.root
  	    }
  
  	    defineProperty(self, 'root', root)
  
  	    // parse the named dom nodes in the looped child
  	    // adding them to the parent as well
  	    if (isLoop)
  	      parseNamedElements(self.root, self.parent, null, true)
  
  	    // if it's not a child tag we can trigger its mount event
  	    if (!self.parent || self.parent.isMounted) {
  	      self.isMounted = true
  	      self.trigger('mount')
  	    }
  	    // otherwise we need to wait that the parent event gets triggered
  	    else self.parent.one('mount', function() {
  	      // avoid to trigger the `mount` event for the tags
  	      // not visible included in an if statement
  	      if (!isInStub(self.root)) {
  	        self.parent.isMounted = self.isMounted = true
  	        self.trigger('mount')
  	      }
  	    })
  	  })
  
  
  	  defineProperty(this, 'unmount', function(keepRootTag) {
  	    var el = root,
  	      p = el.parentNode,
  	      ptag,
  	      tagIndex = __virtualDom.indexOf(self)
  
  	    self.trigger('before-unmount')
  
  	    // remove this tag instance from the global virtualDom variable
  	    if (~tagIndex)
  	      __virtualDom.splice(tagIndex, 1)
  
  	    if (p) {
  
  	      if (parent) {
  	        ptag = getImmediateCustomParentTag(parent)
  	        // remove this tag from the parent tags object
  	        // if there are multiple nested tags with same name..
  	        // remove this element form the array
  	        if (isArray(ptag.tags[tagName]))
  	          each(ptag.tags[tagName], function(tag, i) {
  	            if (tag._riot_id == self._riot_id)
  	              ptag.tags[tagName].splice(i, 1)
  	          })
  	        else
  	          // otherwise just delete the tag instance
  	          ptag.tags[tagName] = undefined
  	      }
  
  	      else
  	        while (el.firstChild) el.removeChild(el.firstChild)
  
  	      if (!keepRootTag)
  	        p.removeChild(el)
  	      else {
  	        // the riot-tag and the data-is attributes aren't needed anymore, remove them
  	        remAttr(p, RIOT_TAG_IS)
  	        remAttr(p, RIOT_TAG) // this will be removed in riot 3.0.0
  	      }
  
  	    }
  
  	    if (this._virts) {
  	      each(this._virts, function(v) {
  	        if (v.parentNode) v.parentNode.removeChild(v)
  	      })
  	    }
  
  	    self.trigger('unmount')
  	    toggle()
  	    self.off('*')
  	    self.isMounted = false
  	    delete root._tag
  
  	  })
  
  	  // proxy function to bind updates
  	  // dispatched from a parent tag
  	  function onChildUpdate(data) { self.update(data, true) }
  
  	  function toggle(isMount) {
  
  	    // mount/unmount children
  	    each(childTags, function(child) { child[isMount ? 'mount' : 'unmount']() })
  
  	    // listen/unlisten parent (events flow one way from parent to children)
  	    if (!parent) return
  	    var evt = isMount ? 'on' : 'off'
  
  	    // the loop tags will be always in sync with the parent automatically
  	    if (isLoop)
  	      parent[evt]('unmount', self.unmount)
  	    else {
  	      parent[evt]('update', onChildUpdate)[evt]('unmount', self.unmount)
  	    }
  	  }
  
  
  	  // named elements available for fn
  	  parseNamedElements(dom, this, childTags)
  
  	}
  	/**
  	 * Attach an event to a DOM node
  	 * @param { String } name - event name
  	 * @param { Function } handler - event callback
  	 * @param { Object } dom - dom node
  	 * @param { Tag } tag - tag instance
  	 */
  	function setEventHandler(name, handler, dom, tag) {
  
  	  dom[name] = function(e) {
  
  	    var ptag = tag._parent,
  	      item = tag._item,
  	      el
  
  	    if (!item)
  	      while (ptag && !item) {
  	        item = ptag._item
  	        ptag = ptag._parent
  	      }
  
  	    // cross browser event fix
  	    e = e || window.event
  
  	    // override the event properties
  	    if (isWritable(e, 'currentTarget')) e.currentTarget = dom
  	    if (isWritable(e, 'target')) e.target = e.srcElement
  	    if (isWritable(e, 'which')) e.which = e.charCode || e.keyCode
  
  	    e.item = item
  
  	    // prevent default behaviour (by default)
  	    if (handler.call(tag, e) !== true && !/radio|check/.test(dom.type)) {
  	      if (e.preventDefault) e.preventDefault()
  	      e.returnValue = false
  	    }
  
  	    if (!e.preventUpdate) {
  	      el = item ? getImmediateCustomParentTag(ptag) : tag
  	      el.update()
  	    }
  
  	  }
  
  	}
  
  
  	/**
  	 * Insert a DOM node replacing another one (used by if- attribute)
  	 * @param   { Object } root - parent node
  	 * @param   { Object } node - node replaced
  	 * @param   { Object } before - node added
  	 */
  	function insertTo(root, node, before) {
  	  if (!root) return
  	  root.insertBefore(before, node)
  	  root.removeChild(node)
  	}
  
  	/**
  	 * Update the expressions in a Tag instance
  	 * @param   { Array } expressions - expression that must be re evaluated
  	 * @param   { Tag } tag - tag instance
  	 */
  	function update(expressions, tag) {
  
  	  each(expressions, function(expr, i) {
  
  	    var dom = expr.dom,
  	      attrName = expr.attr,
  	      value = tmpl(expr.expr, tag),
  	      parent = expr.dom.parentNode
  
  	    if (expr.bool) {
  	      value = !!value
  	    } else if (value == null) {
  	      value = ''
  	    }
  
  	    // #1638: regression of #1612, update the dom only if the value of the
  	    // expression was changed
  	    if (expr.value === value) {
  	      return
  	    }
  	    expr.value = value
  
  	    // textarea and text nodes has no attribute name
  	    if (!attrName) {
  	      // about #815 w/o replace: the browser converts the value to a string,
  	      // the comparison by "==" does too, but not in the server
  	      value += ''
  	      // test for parent avoids error with invalid assignment to nodeValue
  	      if (parent) {
  	        if (parent.tagName === 'TEXTAREA') {
  	          parent.value = value                    // #1113
  	          if (!IE_VERSION) dom.nodeValue = value  // #1625 IE throws here, nodeValue
  	        }                                         // will be available on 'updated'
  	        else dom.nodeValue = value
  	      }
  	      return
  	    }
  
  	    // ~~#1612: look for changes in dom.value when updating the value~~
  	    if (attrName === 'value') {
  	      dom.value = value
  	      return
  	    }
  
  	    // remove original attribute
  	    remAttr(dom, attrName)
  
  	    // event handler
  	    if (isFunction(value)) {
  	      setEventHandler(attrName, value, dom, tag)
  
  	    // if- conditional
  	    } else if (attrName == 'if') {
  	      var stub = expr.stub,
  	        add = function() { insertTo(stub.parentNode, stub, dom) },
  	        remove = function() { insertTo(dom.parentNode, dom, stub) }
  
  	      // add to DOM
  	      if (value) {
  	        if (stub) {
  	          add()
  	          dom.inStub = false
  	          // avoid to trigger the mount event if the tags is not visible yet
  	          // maybe we can optimize this avoiding to mount the tag at all
  	          if (!isInStub(dom)) {
  	            walk(dom, function(el) {
  	              if (el._tag && !el._tag.isMounted)
  	                el._tag.isMounted = !!el._tag.trigger('mount')
  	            })
  	          }
  	        }
  	      // remove from DOM
  	      } else {
  	        stub = expr.stub = stub || document.createTextNode('')
  	        // if the parentNode is defined we can easily replace the tag
  	        if (dom.parentNode)
  	          remove()
  	        // otherwise we need to wait the updated event
  	        else (tag.parent || tag).one('updated', remove)
  
  	        dom.inStub = true
  	      }
  	    // show / hide
  	    } else if (attrName === 'show') {
  	      dom.style.display = value ? '' : 'none'
  
  	    } else if (attrName === 'hide') {
  	      dom.style.display = value ? 'none' : ''
  
  	    } else if (expr.bool) {
  	      dom[attrName] = value
  	      if (value) setAttr(dom, attrName, attrName)
  	      if (FIREFOX && attrName === 'selected' && dom.tagName === 'OPTION') {
  	        dom.__riot1374 = value   // #1374
  	      }
  
  	    } else if (value === 0 || value && typeof value !== T_OBJECT) {
  	      // <img src="{ expr }">
  	      if (startsWith(attrName, RIOT_PREFIX) && attrName != RIOT_TAG) {
  	        attrName = attrName.slice(RIOT_PREFIX.length)
  	      }
  	      setAttr(dom, attrName, value)
  	    }
  
  	  })
  
  	}
  	/**
  	 * Specialized function for looping an array-like collection with `each={}`
  	 * @param   { Array } els - collection of items
  	 * @param   {Function} fn - callback function
  	 * @returns { Array } the array looped
  	 */
  	function each(els, fn) {
  	  var len = els ? els.length : 0
  
  	  for (var i = 0, el; i < len; i++) {
  	    el = els[i]
  	    // return false -> current item was removed by fn during the loop
  	    if (el != null && fn(el, i) === false) i--
  	  }
  	  return els
  	}
  
  	/**
  	 * Detect if the argument passed is a function
  	 * @param   { * } v - whatever you want to pass to this function
  	 * @returns { Boolean } -
  	 */
  	function isFunction(v) {
  	  return typeof v === T_FUNCTION || false   // avoid IE problems
  	}
  
  	/**
  	 * Get the outer html of any DOM node SVGs included
  	 * @param   { Object } el - DOM node to parse
  	 * @returns { String } el.outerHTML
  	 */
  	function getOuterHTML(el) {
  	  if (el.outerHTML) return el.outerHTML
  	  // some browsers do not support outerHTML on the SVGs tags
  	  else {
  	    var container = mkEl('div')
  	    container.appendChild(el.cloneNode(true))
  	    return container.innerHTML
  	  }
  	}
  
  	/**
  	 * Set the inner html of any DOM node SVGs included
  	 * @param { Object } container - DOM node where we will inject the new html
  	 * @param { String } html - html to inject
  	 */
  	function setInnerHTML(container, html) {
  	  if (typeof container.innerHTML != T_UNDEF) container.innerHTML = html
  	  // some browsers do not support innerHTML on the SVGs tags
  	  else {
  	    var doc = new DOMParser().parseFromString(html, 'application/xml')
  	    container.appendChild(
  	      container.ownerDocument.importNode(doc.documentElement, true)
  	    )
  	  }
  	}
  
  	/**
  	 * Checks wether a DOM node must be considered part of an svg document
  	 * @param   { String }  name - tag name
  	 * @returns { Boolean } -
  	 */
  	function isSVGTag(name) {
  	  return ~SVG_TAGS_LIST.indexOf(name)
  	}
  
  	/**
  	 * Detect if the argument passed is an object, exclude null.
  	 * NOTE: Use isObject(x) && !isArray(x) to excludes arrays.
  	 * @param   { * } v - whatever you want to pass to this function
  	 * @returns { Boolean } -
  	 */
  	function isObject(v) {
  	  return v && typeof v === T_OBJECT         // typeof null is 'object'
  	}
  
  	/**
  	 * Remove any DOM attribute from a node
  	 * @param   { Object } dom - DOM node we want to update
  	 * @param   { String } name - name of the property we want to remove
  	 */
  	function remAttr(dom, name) {
  	  dom.removeAttribute(name)
  	}
  
  	/**
  	 * Convert a string containing dashes to camel case
  	 * @param   { String } string - input string
  	 * @returns { String } my-string -> myString
  	 */
  	function toCamel(string) {
  	  return string.replace(/-(\w)/g, function(_, c) {
  	    return c.toUpperCase()
  	  })
  	}
  
  	/**
  	 * Get the value of any DOM attribute on a node
  	 * @param   { Object } dom - DOM node we want to parse
  	 * @param   { String } name - name of the attribute we want to get
  	 * @returns { String | undefined } name of the node attribute whether it exists
  	 */
  	function getAttr(dom, name) {
  	  return dom.getAttribute(name)
  	}
  
  	/**
  	 * Set any DOM attribute
  	 * @param { Object } dom - DOM node we want to update
  	 * @param { String } name - name of the property we want to set
  	 * @param { String } val - value of the property we want to set
  	 */
  	function setAttr(dom, name, val) {
  	  dom.setAttribute(name, val)
  	}
  
  	/**
  	 * Detect the tag implementation by a DOM node
  	 * @param   { Object } dom - DOM node we need to parse to get its tag implementation
  	 * @returns { Object } it returns an object containing the implementation of a custom tag (template and boot function)
  	 */
  	function getTag(dom) {
  	  return dom.tagName && __tagImpl[getAttr(dom, RIOT_TAG_IS) ||
  	    getAttr(dom, RIOT_TAG) || dom.tagName.toLowerCase()]
  	}
  	/**
  	 * Add a child tag to its parent into the `tags` object
  	 * @param   { Object } tag - child tag instance
  	 * @param   { String } tagName - key where the new tag will be stored
  	 * @param   { Object } parent - tag instance where the new child tag will be included
  	 */
  	function addChildTag(tag, tagName, parent) {
  	  var cachedTag = parent.tags[tagName]
  
  	  // if there are multiple children tags having the same name
  	  if (cachedTag) {
  	    // if the parent tags property is not yet an array
  	    // create it adding the first cached tag
  	    if (!isArray(cachedTag))
  	      // don't add the same tag twice
  	      if (cachedTag !== tag)
  	        parent.tags[tagName] = [cachedTag]
  	    // add the new nested tag to the array
  	    if (!contains(parent.tags[tagName], tag))
  	      parent.tags[tagName].push(tag)
  	  } else {
  	    parent.tags[tagName] = tag
  	  }
  	}
  
  	/**
  	 * Move the position of a custom tag in its parent tag
  	 * @param   { Object } tag - child tag instance
  	 * @param   { String } tagName - key where the tag was stored
  	 * @param   { Number } newPos - index where the new tag will be stored
  	 */
  	function moveChildTag(tag, tagName, newPos) {
  	  var parent = tag.parent,
  	    tags
  	  // no parent no move
  	  if (!parent) return
  
  	  tags = parent.tags[tagName]
  
  	  if (isArray(tags))
  	    tags.splice(newPos, 0, tags.splice(tags.indexOf(tag), 1)[0])
  	  else addChildTag(tag, tagName, parent)
  	}
  
  	/**
  	 * Create a new child tag including it correctly into its parent
  	 * @param   { Object } child - child tag implementation
  	 * @param   { Object } opts - tag options containing the DOM node where the tag will be mounted
  	 * @param   { String } innerHTML - inner html of the child node
  	 * @param   { Object } parent - instance of the parent tag including the child custom tag
  	 * @returns { Object } instance of the new child tag just created
  	 */
  	function initChildTag(child, opts, innerHTML, parent) {
  	  var tag = new Tag(child, opts, innerHTML),
  	    tagName = getTagName(opts.root),
  	    ptag = getImmediateCustomParentTag(parent)
  	  // fix for the parent attribute in the looped elements
  	  tag.parent = ptag
  	  // store the real parent tag
  	  // in some cases this could be different from the custom parent tag
  	  // for example in nested loops
  	  tag._parent = parent
  
  	  // add this tag to the custom parent tag
  	  addChildTag(tag, tagName, ptag)
  	  // and also to the real parent tag
  	  if (ptag !== parent)
  	    addChildTag(tag, tagName, parent)
  	  // empty the child node once we got its template
  	  // to avoid that its children get compiled multiple times
  	  opts.root.innerHTML = ''
  
  	  return tag
  	}
  
  	/**
  	 * Loop backward all the parents tree to detect the first custom parent tag
  	 * @param   { Object } tag - a Tag instance
  	 * @returns { Object } the instance of the first custom parent tag found
  	 */
  	function getImmediateCustomParentTag(tag) {
  	  var ptag = tag
  	  while (!getTag(ptag.root)) {
  	    if (!ptag.parent) break
  	    ptag = ptag.parent
  	  }
  	  return ptag
  	}
  
  	/**
  	 * Helper function to set an immutable property
  	 * @param   { Object } el - object where the new property will be set
  	 * @param   { String } key - object key where the new property will be stored
  	 * @param   { * } value - value of the new property
  	* @param   { Object } options - set the propery overriding the default options
  	 * @returns { Object } - the initial object
  	 */
  	function defineProperty(el, key, value, options) {
  	  Object.defineProperty(el, key, extend({
  	    value: value,
  	    enumerable: false,
  	    writable: false,
  	    configurable: true
  	  }, options))
  	  return el
  	}
  
  	/**
  	 * Get the tag name of any DOM node
  	 * @param   { Object } dom - DOM node we want to parse
  	 * @returns { String } name to identify this dom node in riot
  	 */
  	function getTagName(dom) {
  	  var child = getTag(dom),
  	    namedTag = getAttr(dom, 'name'),
  	    tagName = namedTag && !tmpl.hasExpr(namedTag) ?
  	                namedTag :
  	              child ? child.name : dom.tagName.toLowerCase()
  
  	  return tagName
  	}
  
  	/**
  	 * Extend any object with other properties
  	 * @param   { Object } src - source object
  	 * @returns { Object } the resulting extended object
  	 *
  	 * var obj = { foo: 'baz' }
  	 * extend(obj, {bar: 'bar', foo: 'bar'})
  	 * console.log(obj) => {bar: 'bar', foo: 'bar'}
  	 *
  	 */
  	function extend(src) {
  	  var obj, args = arguments
  	  for (var i = 1; i < args.length; ++i) {
  	    if (obj = args[i]) {
  	      for (var key in obj) {
  	        // check if this property of the source object could be overridden
  	        if (isWritable(src, key))
  	          src[key] = obj[key]
  	      }
  	    }
  	  }
  	  return src
  	}
  
  	/**
  	 * Check whether an array contains an item
  	 * @param   { Array } arr - target array
  	 * @param   { * } item - item to test
  	 * @returns { Boolean } Does 'arr' contain 'item'?
  	 */
  	function contains(arr, item) {
  	  return ~arr.indexOf(item)
  	}
  
  	/**
  	 * Check whether an object is a kind of array
  	 * @param   { * } a - anything
  	 * @returns {Boolean} is 'a' an array?
  	 */
  	function isArray(a) { return Array.isArray(a) || a instanceof Array }
  
  	/**
  	 * Detect whether a property of an object could be overridden
  	 * @param   { Object }  obj - source object
  	 * @param   { String }  key - object property
  	 * @returns { Boolean } is this property writable?
  	 */
  	function isWritable(obj, key) {
  	  var props = Object.getOwnPropertyDescriptor(obj, key)
  	  return typeof obj[key] === T_UNDEF || props && props.writable
  	}
  
  
  	/**
  	 * With this function we avoid that the internal Tag methods get overridden
  	 * @param   { Object } data - options we want to use to extend the tag instance
  	 * @returns { Object } clean object without containing the riot internal reserved words
  	 */
  	function cleanUpData(data) {
  	  if (!(data instanceof Tag) && !(data && typeof data.trigger == T_FUNCTION))
  	    return data
  
  	  var o = {}
  	  for (var key in data) {
  	    if (!RESERVED_WORDS_BLACKLIST.test(key)) o[key] = data[key]
  	  }
  	  return o
  	}
  
  	/**
  	 * Walk down recursively all the children tags starting dom node
  	 * @param   { Object }   dom - starting node where we will start the recursion
  	 * @param   { Function } fn - callback to transform the child node just found
  	 */
  	function walk(dom, fn) {
  	  if (dom) {
  	    // stop the recursion
  	    if (fn(dom) === false) return
  	    else {
  	      dom = dom.firstChild
  
  	      while (dom) {
  	        walk(dom, fn)
  	        dom = dom.nextSibling
  	      }
  	    }
  	  }
  	}
  
  	/**
  	 * Minimize risk: only zero or one _space_ between attr & value
  	 * @param   { String }   html - html string we want to parse
  	 * @param   { Function } fn - callback function to apply on any attribute found
  	 */
  	function walkAttributes(html, fn) {
  	  var m,
  	    re = /([-\w]+) ?= ?(?:"([^"]*)|'([^']*)|({[^}]*}))/g
  
  	  while (m = re.exec(html)) {
  	    fn(m[1].toLowerCase(), m[2] || m[3] || m[4])
  	  }
  	}
  
  	/**
  	 * Check whether a DOM node is in stub mode, useful for the riot 'if' directive
  	 * @param   { Object }  dom - DOM node we want to parse
  	 * @returns { Boolean } -
  	 */
  	function isInStub(dom) {
  	  while (dom) {
  	    if (dom.inStub) return true
  	    dom = dom.parentNode
  	  }
  	  return false
  	}
  
  	/**
  	 * Create a generic DOM node
  	 * @param   { String } name - name of the DOM node we want to create
  	 * @param   { Boolean } isSvg - should we use a SVG as parent node?
  	 * @returns { Object } DOM node just created
  	 */
  	function mkEl(name, isSvg) {
  	  return isSvg ?
  	    document.createElementNS('http://www.w3.org/2000/svg', 'svg') :
  	    document.createElement(name)
  	}
  
  	/**
  	 * Shorter and fast way to select multiple nodes in the DOM
  	 * @param   { String } selector - DOM selector
  	 * @param   { Object } ctx - DOM node where the targets of our search will is located
  	 * @returns { Object } dom nodes found
  	 */
  	function $$(selector, ctx) {
  	  return (ctx || document).querySelectorAll(selector)
  	}
  
  	/**
  	 * Shorter and fast way to select a single node in the DOM
  	 * @param   { String } selector - unique dom selector
  	 * @param   { Object } ctx - DOM node where the target of our search will is located
  	 * @returns { Object } dom node found
  	 */
  	function $(selector, ctx) {
  	  return (ctx || document).querySelector(selector)
  	}
  
  	/**
  	 * Simple object prototypal inheritance
  	 * @param   { Object } parent - parent object
  	 * @returns { Object } child instance
  	 */
  	function inherit(parent) {
  	  function Child() {}
  	  Child.prototype = parent
  	  return new Child()
  	}
  
  	/**
  	 * Get the name property needed to identify a DOM node in riot
  	 * @param   { Object } dom - DOM node we need to parse
  	 * @returns { String | undefined } give us back a string to identify this dom node
  	 */
  	function getNamedKey(dom) {
  	  return getAttr(dom, 'id') || getAttr(dom, 'name')
  	}
  
  	/**
  	 * Set the named properties of a tag element
  	 * @param { Object } dom - DOM node we need to parse
  	 * @param { Object } parent - tag instance where the named dom element will be eventually added
  	 * @param { Array } keys - list of all the tag instance properties
  	 */
  	function setNamed(dom, parent, keys) {
  	  // get the key value we want to add to the tag instance
  	  var key = getNamedKey(dom),
  	    isArr,
  	    // add the node detected to a tag instance using the named property
  	    add = function(value) {
  	      // avoid to override the tag properties already set
  	      if (contains(keys, key)) return
  	      // check whether this value is an array
  	      isArr = isArray(value)
  	      // if the key was never set
  	      if (!value)
  	        // set it once on the tag instance
  	        parent[key] = dom
  	      // if it was an array and not yet set
  	      else if (!isArr || isArr && !contains(value, dom)) {
  	        // add the dom node into the array
  	        if (isArr)
  	          value.push(dom)
  	        else
  	          parent[key] = [value, dom]
  	      }
  	    }
  
  	  // skip the elements with no named properties
  	  if (!key) return
  
  	  // check whether this key has been already evaluated
  	  if (tmpl.hasExpr(key))
  	    // wait the first updated event only once
  	    parent.one('mount', function() {
  	      key = getNamedKey(dom)
  	      add(parent[key])
  	    })
  	  else
  	    add(parent[key])
  
  	}
  
  	/**
  	 * Faster String startsWith alternative
  	 * @param   { String } src - source string
  	 * @param   { String } str - test string
  	 * @returns { Boolean } -
  	 */
  	function startsWith(src, str) {
  	  return src.slice(0, str.length) === str
  	}
  
  	/**
  	 * requestAnimationFrame function
  	 * Adapted from https://gist.github.com/paulirish/1579671, license MIT
  	 */
  	var rAF = (function (w) {
  	  var raf = w.requestAnimationFrame    ||
  	            w.mozRequestAnimationFrame || w.webkitRequestAnimationFrame
  
  	  if (!raf || /iP(ad|hone|od).*OS 6/.test(w.navigator.userAgent)) {  // buggy iOS6
  	    var lastTime = 0
  
  	    raf = function (cb) {
  	      var nowtime = Date.now(), timeout = Math.max(16 - (nowtime - lastTime), 0)
  	      setTimeout(function () { cb(lastTime = nowtime + timeout) }, timeout)
  	    }
  	  }
  	  return raf
  
  	})(window || {})
  
  	/**
  	 * Mount a tag creating new Tag instance
  	 * @param   { Object } root - dom node where the tag will be mounted
  	 * @param   { String } tagName - name of the riot tag we want to mount
  	 * @param   { Object } opts - options to pass to the Tag instance
  	 * @returns { Tag } a new Tag instance
  	 */
  	function mountTo(root, tagName, opts) {
  	  var tag = __tagImpl[tagName],
  	    // cache the inner HTML to fix #855
  	    innerHTML = root._innerHTML = root._innerHTML || root.innerHTML
  
  	  // clear the inner html
  	  root.innerHTML = ''
  
  	  if (tag && root) tag = new Tag(tag, { root: root, opts: opts }, innerHTML)
  
  	  if (tag && tag.mount) {
  	    tag.mount()
  	    // add this tag to the virtualDom variable
  	    if (!contains(__virtualDom, tag)) __virtualDom.push(tag)
  	  }
  
  	  return tag
  	}
  	/**
  	 * Riot public api
  	 */
  
  	// share methods for other riot parts, e.g. compiler
  	riot.util = { brackets: brackets, tmpl: tmpl }
  
  	/**
  	 * Create a mixin that could be globally shared across all the tags
  	 */
  	riot.mixin = (function() {
  	  var mixins = {},
  	    globals = mixins[GLOBAL_MIXIN] = {},
  	    _id = 0
  
  	  /**
  	   * Create/Return a mixin by its name
  	   * @param   { String }  name - mixin name (global mixin if object)
  	   * @param   { Object }  mixin - mixin logic
  	   * @param   { Boolean } g - is global?
  	   * @returns { Object }  the mixin logic
  	   */
  	  return function(name, mixin, g) {
  	    // Unnamed global
  	    if (isObject(name)) {
  	      riot.mixin('__unnamed_'+_id++, name, true)
  	      return
  	    }
  
  	    var store = g ? globals : mixins
  
  	    // Getter
  	    if (!mixin) {
  	      if (typeof store[name] === T_UNDEF) {
  	        throw new Error('Unregistered mixin: ' + name)
  	      }
  	      return store[name]
  	    }
  	    // Setter
  	    if (isFunction(mixin)) {
  	      extend(mixin.prototype, store[name] || {})
  	      store[name] = mixin
  	    }
  	    else {
  	      store[name] = extend(store[name] || {}, mixin)
  	    }
  	  }
  
  	})()
  
  	/**
  	 * Create a new riot tag implementation
  	 * @param   { String }   name - name/id of the new riot tag
  	 * @param   { String }   html - tag template
  	 * @param   { String }   css - custom tag css
  	 * @param   { String }   attrs - root tag attributes
  	 * @param   { Function } fn - user function
  	 * @returns { String } name/id of the tag just created
  	 */
  	riot.tag = function(name, html, css, attrs, fn) {
  	  if (isFunction(attrs)) {
  	    fn = attrs
  	    if (/^[\w\-]+\s?=/.test(css)) {
  	      attrs = css
  	      css = ''
  	    } else attrs = ''
  	  }
  	  if (css) {
  	    if (isFunction(css)) fn = css
  	    else styleManager.add(css)
  	  }
  	  name = name.toLowerCase()
  	  __tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }
  	  return name
  	}
  
  	/**
  	 * Create a new riot tag implementation (for use by the compiler)
  	 * @param   { String }   name - name/id of the new riot tag
  	 * @param   { String }   html - tag template
  	 * @param   { String }   css - custom tag css
  	 * @param   { String }   attrs - root tag attributes
  	 * @param   { Function } fn - user function
  	 * @returns { String } name/id of the tag just created
  	 */
  	riot.tag2 = function(name, html, css, attrs, fn) {
  	  if (css) styleManager.add(css)
  	  //if (bpair) riot.settings.brackets = bpair
  	  __tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }
  	  return name
  	}
  
  	/**
  	 * Mount a tag using a specific tag implementation
  	 * @param   { String } selector - tag DOM selector
  	 * @param   { String } tagName - tag implementation name
  	 * @param   { Object } opts - tag logic
  	 * @returns { Array } new tags instances
  	 */
  	riot.mount = function(selector, tagName, opts) {
  
  	  var els,
  	    allTags,
  	    tags = []
  
  	  // helper functions
  
  	  function addRiotTags(arr) {
  	    var list = ''
  	    each(arr, function (e) {
  	      if (!/[^-\w]/.test(e)) {
  	        e = e.trim().toLowerCase()
  	        list += ',[' + RIOT_TAG_IS + '="' + e + '"],[' + RIOT_TAG + '="' + e + '"]'
  	      }
  	    })
  	    return list
  	  }
  
  	  function selectAllTags() {
  	    var keys = Object.keys(__tagImpl)
  	    return keys + addRiotTags(keys)
  	  }
  
  	  function pushTags(root) {
  	    if (root.tagName) {
  	      var riotTag = getAttr(root, RIOT_TAG_IS) || getAttr(root, RIOT_TAG)
  
  	      // have tagName? force riot-tag to be the same
  	      if (tagName && riotTag !== tagName) {
  	        riotTag = tagName
  	        setAttr(root, RIOT_TAG_IS, tagName)
  	        setAttr(root, RIOT_TAG, tagName) // this will be removed in riot 3.0.0
  	      }
  	      var tag = mountTo(root, riotTag || root.tagName.toLowerCase(), opts)
  
  	      if (tag) tags.push(tag)
  	    } else if (root.length) {
  	      each(root, pushTags)   // assume nodeList
  	    }
  	  }
  
  	  // ----- mount code -----
  
  	  // inject styles into DOM
  	  styleManager.inject()
  
  	  if (isObject(tagName)) {
  	    opts = tagName
  	    tagName = 0
  	  }
  
  	  // crawl the DOM to find the tag
  	  if (typeof selector === T_STRING) {
  	    if (selector === '*')
  	      // select all the tags registered
  	      // and also the tags found with the riot-tag attribute set
  	      selector = allTags = selectAllTags()
  	    else
  	      // or just the ones named like the selector
  	      selector += addRiotTags(selector.split(/, */))
  
  	    // make sure to pass always a selector
  	    // to the querySelectorAll function
  	    els = selector ? $$(selector) : []
  	  }
  	  else
  	    // probably you have passed already a tag or a NodeList
  	    els = selector
  
  	  // select all the registered and mount them inside their root elements
  	  if (tagName === '*') {
  	    // get all custom tags
  	    tagName = allTags || selectAllTags()
  	    // if the root els it's just a single tag
  	    if (els.tagName)
  	      els = $$(tagName, els)
  	    else {
  	      // select all the children for all the different root elements
  	      var nodeList = []
  	      each(els, function (_el) {
  	        nodeList.push($$(tagName, _el))
  	      })
  	      els = nodeList
  	    }
  	    // get rid of the tagName
  	    tagName = 0
  	  }
  
  	  pushTags(els)
  
  	  return tags
  	}
  
  	/**
  	 * Update all the tags instances created
  	 * @returns { Array } all the tags instances
  	 */
  	riot.update = function() {
  	  return each(__virtualDom, function(tag) {
  	    tag.update()
  	  })
  	}
  
  	/**
  	 * Export the Virtual DOM
  	 */
  	riot.vdom = __virtualDom
  
  	/**
  	 * Export the Tag constructor
  	 */
  	riot.Tag = Tag
  	  // support CommonJS, AMD & browser
  	  /* istanbul ignore next */
  	  if (typeof exports === T_OBJECT)
  	    module.exports = riot
  	  else if ("function" === T_FUNCTION && typeof __webpack_require__(36) !== T_UNDEF)
  	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function() { return riot }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))
  	  else
  	    window.riot = riot
  
  	})(typeof window != 'undefined' ? window : void 0);
  
  
  /***/ },
  /* 36 */
  /***/ function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {module.exports = __webpack_amd_options__;
  
  	/* WEBPACK VAR INJECTION */}.call(exports, {}))
  
  /***/ },
  /* 37 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-query', '<input class="gb-search-box {opts.stylish ? \'gb-stylish\' : \'\'}" type="text" name="searchBox" oninput="{updateResults}" placeholder="Search...">', 'gb-query .gb-stylish.gb-search-box,[riot-tag="gb-query"] .gb-stylish.gb-search-box,[data-is="gb-query"] .gb-stylish.gb-search-box{ padding: 6px 12px; font-size: 14px; }', '', function (opts) {
  	  var _this = this;
  
  	  this.updateResults = function () {
  	    opts.srch.search(_this.searchBox.value);
  	  };
  	  opts.srch.el.on('results', function () {
  	    _this.searchBox.value = opts.srch.query.build().query;
  	  });
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ },
  /* 38 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-results', '<div each="{records}"> <a href="#"> <img riot-src="{allMeta[struct.image]}" alt=""> </a> <a href="#"> <p>{allMeta[struct.title]}</p> <p>{allMeta[struct.price]}</p> </a> </div>', '', '', function (opts) {
  	  var _this = this;
  
  	  this.struct = opts.srch.CONFIG.structure;
  
  	  opts.srch.el.on('results', function () {
  	    _this.records = opts.srch.results.records;
  	    _this.update();
  	  });
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ },
  /* 39 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-record-count', '<h2>{first} - {last} of {total} Products</h2>', '', '', function (opts) {
  	  var _this = this;
  
  	  opts.srch.el.on('results', function () {
  	    _this.first = opts.srch.results.pageInfo.recordStart;
  	    _this.last = opts.srch.results.pageInfo.recordEnd;
  	    _this.total = opts.srch.results.totalRecordCount;
  	    _this.update();
  	  });
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ },
  /* 40 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-paging', '<div class="gb-paging {opts.stylish ? \'gb-stylish\' : \'\'}"> <a class="gb-paging__link prev" href="#" onclick="{prevPage}"><span class="gb-paging__icon prev">←</span> Prev</a> <a class="gb-paging__link next" href="#" onclick="{nextPage}">Next <span class="gb-paging__icon next">→</span></a> </div>', 'gb-paging .gb-stylish .gb-paging__link,[riot-tag="gb-paging"] .gb-stylish .gb-paging__link,[data-is="gb-paging"] .gb-stylish .gb-paging__link{ padding: 5px 14px; text-decoration: none; }', '', function (opts) {
  	  var _this = this;
  
  	  opts.srch.el.on('results', function () {
  	    _this.update();
  	  });
  
  	  this.nextPage = function () {
  	    var step = _this.step(true);
  	    if (_this.hasNext()) _this.paginate(step);
  	  };
  	  this.prevPage = function () {
  	    var step = _this.step(false);
  	    if (_this.hasPrev()) _this.paginate(step);
  	  };
  
  	  this.hasNext = function () {
  	    return _this.step(true) < opts.srch.results.totalRecordCount;
  	  };
  	  this.hasPrev = function () {
  	    return opts.srch.state.lastStep !== 0;
  	  };
  
  	  this.paginate = function (step) {
  	    if (step != opts.srch.state.lastStep) {
  	      opts.srch.state.lastStep = step;
  	      opts.srch.search(opts.srch.query.skip(step));
  	    }
  	  };
  
  	  this.step = function (add) {
  	    var records = opts.srch.results.records.length;
  	    var skip = opts.srch.state.lastStep + (add ? records : -records);
  	    return skip >= 0 ? skip : 0;
  	  };
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ },
  /* 41 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-related-searches', '<h3>Related Queries:</h3> <ul class="gb-list"> <li each="{related in relatedSearches}"> <a href="#" onclick="{send}">{related}</a> </li> </ul>', '', '', function (opts) {
  	  var _this = this;
  
  	  opts.srch.el.on('results', function () {
  	    _this.relatedSearches = opts.srch.results.relatedQueries;
  	    _this.update();
  	  });
  
  	  this.send = function (event) {
  	    return opts.srch.search(event.target.text);
  	  };
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ },
  /* 42 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-did-you-mean', '<h3>Did You Mean:</h3> <ul class="gb-list"> <li each="{dym in didYouMean}"> <a href="#" onclick="{send}">{dym}</a> </li> </ul>', '', '', function (opts) {
  	  var _this = this;
  
  	  opts.srch.el.on('results', function () {
  	    _this.didYouMean = opts.srch.results.didYouMean;
  	    _this.update();
  	  });
  
  	  this.send = function (event) {
  	    return opts.srch.search(event.target.text);
  	  };
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ },
  /* 43 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-available-navigation', '<div class="gb-side-nav {stylish ? \'gb-stylish\' : \'\'}"> <div class="gb-nav" each="{nav in availableNavigation}"> <h4 class="gb-nav__title">{nav.displayName}</h4> <ul class="gb-nav__list"> <gb-available-refinement each="{ref in nav.refinements}" srch="{srch}" ref="{ref}"></gb-available-refinement> </ul> </div> </div>', 'gb-available-navigation .gb-stylish h4,[riot-tag="gb-available-navigation"] .gb-stylish h4,[data-is="gb-available-navigation"] .gb-stylish h4{ font-size: 18px; margin: 10px 0; } gb-available-navigation .gb-stylish.gb-side-nav,[riot-tag="gb-available-navigation"] .gb-stylish.gb-side-nav,[data-is="gb-available-navigation"] .gb-stylish.gb-side-nav{ padding: 12px; } gb-available-navigation .gb-stylish .gb-nav__list,[riot-tag="gb-available-navigation"] .gb-stylish .gb-nav__list,[data-is="gb-available-navigation"] .gb-stylish .gb-nav__list{ margin: 0; padding-left: 8px; }', '', function (opts) {
  	    var _this = this;
  
  	    __webpack_require__(44);
  
  	    this.srch = opts.srch;
  	    this.stylish = opts.stylish;
  	    this.badge = opts.badge === undefined ? true : opts.badge;
  
  	    opts.srch.el.on('results', function () {
  	        _this.availableNavigation = opts.srch.results.availableNavigation;
  	        _this.update();
  	    });
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ },
  /* 44 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-available-refinement', '<li class="gb-ref {parent.stylish ? \'gb-stylish\' : \'\'}"> <a class="gb-ref__link" href="#" onclick="{send}"> <span class="gb-ref__title">{ref.type === \'Value\' ? ref.value : ref.low + \' - \' + ref.high}</span> <span class="gb-filler"></span> <span class="gb-ref__badge" if="{parent.badge}">{ref.count}</span> </a> </li>', 'gb-available-refinement .gb-stylish,[riot-tag="gb-available-refinement"] .gb-stylish,[data-is="gb-available-refinement"] .gb-stylish{ list-style: none; } gb-available-refinement .gb-stylish .gb-filler,[riot-tag="gb-available-refinement"] .gb-stylish .gb-filler,[data-is="gb-available-refinement"] .gb-stylish .gb-filler{ flex-grow: 1; } gb-available-refinement .gb-stylish .gb-ref__link,[riot-tag="gb-available-refinement"] .gb-stylish .gb-ref__link,[data-is="gb-available-refinement"] .gb-stylish .gb-ref__link{ display: flex; padding: 4px 6px; border-radius: 4px; color: black; font-size: 14px; text-decoration: none; align-items: center; } gb-available-refinement .gb-stylish .gb-ref__link:hover,[riot-tag="gb-available-refinement"] .gb-stylish .gb-ref__link:hover,[data-is="gb-available-refinement"] .gb-stylish .gb-ref__link:hover{ background-color: #ddd; } gb-available-refinement .gb-stylish .gb-ref__badge,[riot-tag="gb-available-refinement"] .gb-stylish .gb-ref__badge,[data-is="gb-available-refinement"] .gb-stylish .gb-ref__badge{ display: inline-block; min-width: 10px; max-height: 12px; padding: 3px 7px; border-radius: 10px; font-size: 12px; font-weight: bold; line-height: 1; color: #fff; background-color: #ccc; text-align: center; white-space: nowrap; vertical-align: middle; }', '', function (opts) {
  	  var _this = this;
  
  	  var srch = this.parent.srch;
  
  	  this.send = function () {
  	    var selectedRefinement = _this.generateSelectedRefinement();
  	    srch.search(srch.query.withSelectedRefinements(selectedRefinement));
  	    srch.state.refinements.push(selectedRefinement);
  	  };
  
  	  this.generateSelectedRefinement = function () {
  	    return new Object({
  	      navigationName: _this.parent.nav.name,
  	      type: opts.ref.type,
  	      value: opts.ref.value,
  	      low: opts.ref.low,
  	      high: opts.ref.high
  	    });
  	  };
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ },
  /* 45 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-selected-navigation', '<ul class="gb-list"> <li each="{nav in selectedNavigation}" nav="{nav}"> <ul class="gb-list"> <gb-selected-refinement each="{ref in nav.refinements}" nav="{nav}" ref="{ref}" srch="{srch}"></gb-selected-refinement> </ul> </li> </ul>', '', '', function (opts) {
  	  var _this = this;
  
  	  __webpack_require__(46);
  
  	  this.srch = opts.srch;
  	  opts.srch.el.on('results', function () {
  	    _this.selectedNavigation = opts.srch.results.selectedNavigation;
  	    _this.update();
  	  });
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ },
  /* 46 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(riot) {'use strict';
  
  	riot.tag2('gb-selected-refinement', '<li> <a href="#" onclick="{remove}">x</a> <b>{opts.nav.displayName}: {ref.type === \'Value\' ? ref.value : ref.low + \' .. \' + ref.high}</b> </li>', '', '', function (opts) {
  	  var _this = this;
  
  	  this.remove = function () {
  	    opts.srch.state.refinements.splice(opts.srch.state.refinements.findIndex(_this.matchesRefinement), 1);
  	  };
  
  	  this.matchesRefinement = function (ref) {
  	    return ref.type === 'Value' ? ref.value === opts.ref.value : ref.low === opts.ref.low && ref.high === opts.ref.high;
  	  };
  	});
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
  
  /***/ }
  /******/ ]);