/*! docsearch 2.6.3 | 漏 Algolia | github.com/algolia/docsearch */
(function webpackUniversalModuleDefinition(root, factory) {
  if (typeof exports === 'object' && typeof module === 'object') module.exports = factory();
  else if (typeof define === 'function' && define.amd) define([], factory);
  else if (typeof exports === 'object') exports['docsearch'] = factory();
  else root['docsearch'] = factory();
})(typeof self !== 'undefined' ? self : this, function () {
  return (function (modules) {
    var installedModules = {};
    function __webpack_require__(moduleId) {
      if (installedModules[moduleId]) {
        return installedModules[moduleId].exports;
      }
      var module = (installedModules[moduleId] = { i: moduleId, l: false, exports: {} });
      modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
      module.l = true;
      return module.exports;
    }
    __webpack_require__.m = modules;
    __webpack_require__.c = installedModules;
    __webpack_require__.d = function (exports, name, getter) {
      if (!__webpack_require__.o(exports, name)) {
        Object.defineProperty(exports, name, {
          configurable: false,
          enumerable: true,
          get: getter,
        });
      }
    };
    __webpack_require__.n = function (module) {
      var getter =
        module && module.__esModule
          ? function getDefault() {
              return module['default'];
            }
          : function getModuleExports() {
              return module;
            };
      __webpack_require__.d(getter, 'a', getter);
      return getter;
    };
    __webpack_require__.o = function (object, property) {
      return Object.prototype.hasOwnProperty.call(object, property);
    };
    __webpack_require__.p = '';
    return __webpack_require__((__webpack_require__.s = 22));
  })([
    function (module, exports, __webpack_require__) {
      'use strict';
      var DOM = __webpack_require__(1);
      function escapeRegExp(str) {
        return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
      }
      module.exports = {
        isArray: null,
        isFunction: null,
        isObject: null,
        bind: null,
        each: null,
        map: null,
        mixin: null,
        isMsie: function (agentString) {
          if (agentString === undefined) {
            agentString = navigator.userAgent;
          }
          if (/(msie|trident)/i.test(agentString)) {
            var match = agentString.match(/(msie |rv:)(\d+(.\d+)?)/i);
            if (match) {
              return match[2];
            }
          }
          return false;
        },
        escapeRegExChars: function (str) {
          return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
        },
        isNumber: function (obj) {
          return typeof obj === 'number';
        },
        toStr: function toStr(s) {
          return s === undefined || s === null ? '' : s + '';
        },
        cloneDeep: function cloneDeep(obj) {
          var clone = this.mixin({}, obj);
          var self = this;
          this.each(clone, function (value, key) {
            if (value) {
              if (self.isArray(value)) {
                clone[key] = [].concat(value);
              } else if (self.isObject(value)) {
                clone[key] = self.cloneDeep(value);
              }
            }
          });
          return clone;
        },
        error: function (msg) {
          throw new Error(msg);
        },
        every: function (obj, test) {
          var result = true;
          if (!obj) {
            return result;
          }
          this.each(obj, function (val, key) {
            if (result) {
              result = test.call(null, val, key, obj) && result;
            }
          });
          return !!result;
        },
        any: function (obj, test) {
          var found = false;
          if (!obj) {
            return found;
          }
          this.each(obj, function (val, key) {
            if (test.call(null, val, key, obj)) {
              found = true;
              return false;
            }
          });
          return found;
        },
        getUniqueId: (function () {
          var counter = 0;
          return function () {
            return counter++;
          };
        })(),
        templatify: function templatify(obj) {
          if (this.isFunction(obj)) {
            return obj;
          }
          var $template = DOM.element(obj);
          if ($template.prop('tagName') === 'SCRIPT') {
            return function template() {
              return $template.text();
            };
          }
          return function template() {
            return String(obj);
          };
        },
        defer: function (fn) {
          setTimeout(fn, 0);
        },
        noop: function () {},
        formatPrefix: function (prefix, noPrefix) {
          return noPrefix ? '' : prefix + '-';
        },
        className: function (prefix, clazz, skipDot) {
          return (skipDot ? '' : '.') + prefix + clazz;
        },
        escapeHighlightedString: function (str, highlightPreTag, highlightPostTag) {
          highlightPreTag = highlightPreTag || '<em>';
          var pre = document.createElement('div');
          pre.appendChild(document.createTextNode(highlightPreTag));
          highlightPostTag = highlightPostTag || '</em>';
          var post = document.createElement('div');
          post.appendChild(document.createTextNode(highlightPostTag));
          var div = document.createElement('div');
          div.appendChild(document.createTextNode(str));
          return div.innerHTML
            .replace(RegExp(escapeRegExp(pre.innerHTML), 'g'), highlightPreTag)
            .replace(RegExp(escapeRegExp(post.innerHTML), 'g'), highlightPostTag);
        },
      };
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      module.exports = { element: null };
    },
    function (module, exports) {
      var hasOwn = Object.prototype.hasOwnProperty;
      var toString = Object.prototype.toString;
      module.exports = function forEach(obj, fn, ctx) {
        if (toString.call(fn) !== '[object Function]') {
          throw new TypeError('iterator must be a function');
        }
        var l = obj.length;
        if (l === +l) {
          for (var i = 0; i < l; i++) {
            fn.call(ctx, obj[i], i, obj);
          }
        } else {
          for (var k in obj) {
            if (hasOwn.call(obj, k)) {
              fn.call(ctx, obj[k], k, obj);
            }
          }
        }
      };
    },
    function (module, exports) {
      module.exports = function clone(obj) {
        return JSON.parse(JSON.stringify(obj));
      };
    },
    function (module, exports) {
      var g;
      g = (function () {
        return this;
      })();
      try {
        g = g || Function('return this')() || (1, eval)('this');
      } catch (e) {
        if (typeof window === 'object') g = window;
      }
      module.exports = g;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var inherits = __webpack_require__(12);
      function AlgoliaSearchError(message, extraProperties) {
        var forEach = __webpack_require__(2);
        var error = this;
        if (typeof Error.captureStackTrace === 'function') {
          Error.captureStackTrace(this, this.constructor);
        } else {
          error.stack = new Error().stack || 'Cannot get a stacktrace, browser is too old';
        }
        this.name = 'AlgoliaSearchError';
        this.message = message || 'Unknown error';
        if (extraProperties) {
          forEach(extraProperties, function addToErrorObject(value, key) {
            error[key] = value;
          });
        }
      }
      inherits(AlgoliaSearchError, Error);
      function createCustomError(name, message) {
        function AlgoliaSearchCustomError() {
          var args = Array.prototype.slice.call(arguments, 0);
          if (typeof args[0] !== 'string') {
            args.unshift(message);
          }
          AlgoliaSearchError.apply(this, args);
          this.name = 'AlgoliaSearch' + name + 'Error';
        }
        inherits(AlgoliaSearchCustomError, AlgoliaSearchError);
        return AlgoliaSearchCustomError;
      }
      module.exports = {
        AlgoliaSearchError: AlgoliaSearchError,
        UnparsableJSON: createCustomError(
          'UnparsableJSON',
          'Could not parse the incoming response as JSON, see err.more for details',
        ),
        RequestTimeout: createCustomError(
          'RequestTimeout',
          'Request timedout before getting a response',
        ),
        Network: createCustomError('Network', 'Network issue, see err.more for details'),
        JSONPScriptFail: createCustomError(
          'JSONPScriptFail',
          '<script> was loaded but did not call our provided callback',
        ),
        JSONPScriptError: createCustomError(
          'JSONPScriptError',
          '<script> unable to load due to an `error` event on it',
        ),
        Unknown: createCustomError('Unknown', 'Unknown error occured'),
      };
    },
    function (module, exports) {
      var toString = {}.toString;
      module.exports =
        Array.isArray ||
        function (arr) {
          return toString.call(arr) == '[object Array]';
        };
    },
    function (module, exports, __webpack_require__) {
      var foreach = __webpack_require__(2);
      module.exports = function map(arr, fn) {
        var newArr = [];
        foreach(arr, function (item, itemIndex) {
          newArr.push(fn(item, itemIndex, arr));
        });
        return newArr;
      };
    },
    function (module, exports, __webpack_require__) {
      (function (process) {
        exports = module.exports = __webpack_require__(39);
        exports.log = log;
        exports.formatArgs = formatArgs;
        exports.save = save;
        exports.load = load;
        exports.useColors = useColors;
        exports.storage =
          'undefined' != typeof chrome && 'undefined' != typeof chrome.storage
            ? chrome.storage.local
            : localstorage();
        exports.colors = [
          'lightseagreen',
          'forestgreen',
          'goldenrod',
          'dodgerblue',
          'darkorchid',
          'crimson',
        ];
        function useColors() {
          if (
            typeof window !== 'undefined' &&
            window.process &&
            window.process.type === 'renderer'
          ) {
            return true;
          }
          return (
            (typeof document !== 'undefined' &&
              document.documentElement &&
              document.documentElement.style &&
              document.documentElement.style.WebkitAppearance) ||
            (typeof window !== 'undefined' &&
              window.console &&
              (window.console.firebug || (window.console.exception && window.console.table))) ||
            (typeof navigator !== 'undefined' &&
              navigator.userAgent &&
              navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) &&
              parseInt(RegExp.$1, 10) >= 31) ||
            (typeof navigator !== 'undefined' &&
              navigator.userAgent &&
              navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/))
          );
        }
        exports.formatters.j = function (v) {
          try {
            return JSON.stringify(v);
          } catch (err) {
            return '[UnexpectedJSONParseError]: ' + err.message;
          }
        };
        function formatArgs(args) {
          var useColors = this.useColors;
          args[0] =
            (useColors ? '%c' : '') +
            this.namespace +
            (useColors ? ' %c' : ' ') +
            args[0] +
            (useColors ? '%c ' : ' ') +
            '+' +
            exports.humanize(this.diff);
          if (!useColors) return;
          var c = 'color: ' + this.color;
          args.splice(1, 0, c, 'color: inherit');
          var index = 0;
          var lastC = 0;
          args[0].replace(/%[a-zA-Z%]/g, function (match) {
            if ('%%' === match) return;
            index++;
            if ('%c' === match) {
              lastC = index;
            }
          });
          args.splice(lastC, 0, c);
        }
        function log() {
          return (
            'object' === typeof console &&
            console.log &&
            Function.prototype.apply.call(console.log, console, arguments)
          );
        }
        function save(namespaces) {
          try {
            if (null == namespaces) {
              exports.storage.removeItem('debug');
            } else {
              exports.storage.debug = namespaces;
            }
          } catch (e) {}
        }
        function load() {
          var r;
          try {
            r = exports.storage.debug;
          } catch (e) {}
          if (!r && typeof process !== 'undefined' && 'env' in process) {
            r = Object({ NODE_ENV: 'production' }).DEBUG;
          }
          return r;
        }
        exports.enable(load());
        function localstorage() {
          try {
            return window.localStorage;
          } catch (e) {}
        }
      }).call(exports, __webpack_require__(9));
    },
    function (module, exports) {
      var process = (module.exports = {});
      var cachedSetTimeout;
      var cachedClearTimeout;
      function defaultSetTimout() {
        throw new Error('setTimeout has not been defined');
      }
      function defaultClearTimeout() {
        throw new Error('clearTimeout has not been defined');
      }
      (function () {
        try {
          if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
          } else {
            cachedSetTimeout = defaultSetTimout;
          }
        } catch (e) {
          cachedSetTimeout = defaultSetTimout;
        }
        try {
          if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
          } else {
            cachedClearTimeout = defaultClearTimeout;
          }
        } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
        }
      })();
      function runTimeout(fun) {
        if (cachedSetTimeout === setTimeout) {
          return setTimeout(fun, 0);
        }
        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
        }
        try {
          return cachedSetTimeout(fun, 0);
        } catch (e) {
          try {
            return cachedSetTimeout.call(null, fun, 0);
          } catch (e) {
            return cachedSetTimeout.call(this, fun, 0);
          }
        }
      }
      function runClearTimeout(marker) {
        if (cachedClearTimeout === clearTimeout) {
          return clearTimeout(marker);
        }
        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
        }
        try {
          return cachedClearTimeout(marker);
        } catch (e) {
          try {
            return cachedClearTimeout.call(null, marker);
          } catch (e) {
            return cachedClearTimeout.call(this, marker);
          }
        }
      }
      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 = runTimeout(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;
        runClearTimeout(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) {
          runTimeout(drainQueue);
        }
      };
      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 = '';
      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.prependListener = noop;
      process.prependOnceListener = noop;
      process.listeners = function (name) {
        return [];
      };
      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;
      };
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var immediate = __webpack_require__(53);
      var splitter = /\s+/;
      module.exports = { onSync: onSync, onAsync: onAsync, off: off, trigger: trigger };
      function on(method, types, cb, context) {
        var type;
        if (!cb) {
          return this;
        }
        types = types.split(splitter);
        cb = context ? bindContext(cb, context) : cb;
        this._callbacks = this._callbacks || {};
        while ((type = types.shift())) {
          this._callbacks[type] = this._callbacks[type] || { sync: [], async: [] };
          this._callbacks[type][method].push(cb);
        }
        return this;
      }
      function onAsync(types, cb, context) {
        return on.call(this, 'async', types, cb, context);
      }
      function onSync(types, cb, context) {
        return on.call(this, 'sync', types, cb, context);
      }
      function off(types) {
        var type;
        if (!this._callbacks) {
          return this;
        }
        types = types.split(splitter);
        while ((type = types.shift())) {
          delete this._callbacks[type];
        }
        return this;
      }
      function trigger(types) {
        var type;
        var callbacks;
        var args;
        var syncFlush;
        var asyncFlush;
        if (!this._callbacks) {
          return this;
        }
        types = types.split(splitter);
        args = [].slice.call(arguments, 1);
        while ((type = types.shift()) && (callbacks = this._callbacks[type])) {
          syncFlush = getFlush(callbacks.sync, this, [type].concat(args));
          asyncFlush = getFlush(callbacks.async, this, [type].concat(args));
          if (syncFlush()) {
            immediate(asyncFlush);
          }
        }
        return this;
      }
      function getFlush(callbacks, context, args) {
        return flush;
        function flush() {
          var cancelled;
          for (var i = 0, len = callbacks.length; !cancelled && i < len; i += 1) {
            cancelled = callbacks[i].apply(context, args) === false;
          }
          return !cancelled;
        }
      }
      function bindContext(fn, context) {
        return fn.bind
          ? fn.bind(context)
          : function () {
              fn.apply(context, [].slice.call(arguments, 0));
            };
      }
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var _ = __webpack_require__(0);
      var css = {
        wrapper: { position: 'relative', display: 'inline-block' },
        hint: {
          position: 'absolute',
          top: '0',
          left: '0',
          borderColor: 'transparent',
          boxShadow: 'none',
          opacity: '1',
        },
        input: { position: 'relative', verticalAlign: 'top', backgroundColor: 'transparent' },
        inputWithNoHint: { position: 'relative', verticalAlign: 'top' },
        dropdown: { position: 'absolute', top: '100%', left: '0', zIndex: '100', display: 'none' },
        suggestions: { display: 'block' },
        suggestion: { whiteSpace: 'nowrap', cursor: 'pointer' },
        suggestionChild: { whiteSpace: 'normal' },
        ltr: { left: '0', right: 'auto' },
        rtl: { left: 'auto', right: '0' },
        defaultClasses: {
          root: 'algolia-autocomplete',
          prefix: 'aa',
          noPrefix: false,
          dropdownMenu: 'dropdown-menu',
          input: 'input',
          hint: 'hint',
          suggestions: 'suggestions',
          suggestion: 'suggestion',
          cursor: 'cursor',
          dataset: 'dataset',
          empty: 'empty',
        },
        appendTo: {
          wrapper: { position: 'absolute', zIndex: '100', display: 'none' },
          input: {},
          inputWithNoHint: {},
          dropdown: { display: 'block' },
        },
      };
      if (_.isMsie()) {
        _.mixin(css.input, {
          backgroundImage:
            'url(data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)',
        });
      }
      if (_.isMsie() && _.isMsie() <= 7) {
        _.mixin(css.input, { marginTop: '-1px' });
      }
      module.exports = css;
    },
    function (module, exports) {
      if (typeof Object.create === 'function') {
        module.exports = function inherits(ctor, superCtor) {
          ctor.super_ = superCtor;
          ctor.prototype = Object.create(superCtor.prototype, {
            constructor: { value: ctor, enumerable: false, writable: true, configurable: true },
          });
        };
      } else {
        module.exports = function inherits(ctor, superCtor) {
          ctor.super_ = superCtor;
          var TempCtor = function () {};
          TempCtor.prototype = superCtor.prototype;
          ctor.prototype = new TempCtor();
          ctor.prototype.constructor = ctor;
        };
      }
    },
    function (module, exports, __webpack_require__) {
      module.exports = buildSearchMethod;
      var errors = __webpack_require__(5);
      function buildSearchMethod(queryParam, url) {
        return function search(query, args, callback) {
          if (
            (typeof query === 'function' && typeof args === 'object') ||
            typeof callback === 'object'
          ) {
            throw new errors.AlgoliaSearchError(
              'index.search usage is index.search(query, params, cb)',
            );
          }
          if (arguments.length === 0 || typeof query === 'function') {
            callback = query;
            query = '';
          } else if (arguments.length === 1 || typeof args === 'function') {
            callback = args;
            args = undefined;
          }
          if (typeof query === 'object' && query !== null) {
            args = query;
            query = undefined;
          } else if (query === undefined || query === null) {
            query = '';
          }
          var params = '';
          if (query !== undefined) {
            params += queryParam + '=' + encodeURIComponent(query);
          }
          var additionalUA;
          if (args !== undefined) {
            if (args.additionalUA) {
              additionalUA = args.additionalUA;
              delete args.additionalUA;
            }
            params = this.as._getSearchParams(args, params);
          }
          return this._search(params, url, callback, additionalUA);
        };
      }
    },
    function (module, exports, __webpack_require__) {
      module.exports = function omit(obj, test) {
        var keys = __webpack_require__(36);
        var foreach = __webpack_require__(2);
        var filtered = {};
        foreach(keys(obj), function doFilter(keyName) {
          if (test(keyName) !== true) {
            filtered[keyName] = obj[keyName];
          }
        });
        return filtered;
      };
    },
    function (module, exports) {
      (function (global, factory) {
        module.exports = factory(global);
      })(window, function (window) {
        var Zepto = (function () {
          var undefined,
            key,
            $,
            classList,
            emptyArray = [],
            concat = emptyArray.concat,
            filter = emptyArray.filter,
            slice = emptyArray.slice,
            document = window.document,
            elementDisplay = {},
            classCache = {},
            cssNumber = {
              'column-count': 1,
              columns: 1,
              'font-weight': 1,
              'line-height': 1,
              opacity: 1,
              'z-index': 1,
              zoom: 1,
            },
            fragmentRE = /^\s*<(\w+|!)[^>]*>/,
            singleTagRE = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
            tagExpanderRE =
              /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
            rootNodeRE = /^(?:body|html)$/i,
            capitalRE = /([A-Z])/g,
            methodAttributes = ['val', 'css', 'html', 'text', 'data', 'width', 'height', 'offset'],
            adjacencyOperators = ['after', 'prepend', 'before', 'append'],
            table = document.createElement('table'),
            tableRow = document.createElement('tr'),
            containers = {
              tr: document.createElement('tbody'),
              tbody: table,
              thead: table,
              tfoot: table,
              td: tableRow,
              th: tableRow,
              '*': document.createElement('div'),
            },
            readyRE = /complete|loaded|interactive/,
            simpleSelectorRE = /^[\w-]*$/,
            class2type = {},
            toString = class2type.toString,
            zepto = {},
            camelize,
            uniq,
            tempParent = document.createElement('div'),
            propMap = {
              tabindex: 'tabIndex',
              readonly: 'readOnly',
              for: 'htmlFor',
              class: 'className',
              maxlength: 'maxLength',
              cellspacing: 'cellSpacing',
              cellpadding: 'cellPadding',
              rowspan: 'rowSpan',
              colspan: 'colSpan',
              usemap: 'useMap',
              frameborder: 'frameBorder',
              contenteditable: 'contentEditable',
            },
            isArray =
              Array.isArray ||
              function (object) {
                return object instanceof Array;
              };
          zepto.matches = function (element, selector) {
            if (!selector || !element || element.nodeType !== 1) return false;
            var matchesSelector =
              element.matches ||
              element.webkitMatchesSelector ||
              element.mozMatchesSelector ||
              element.oMatchesSelector ||
              element.matchesSelector;
            if (matchesSelector) return matchesSelector.call(element, selector);
            var match,
              parent = element.parentNode,
              temp = !parent;
            if (temp) (parent = tempParent).appendChild(element);
            match = ~zepto.qsa(parent, selector).indexOf(element);
            temp && tempParent.removeChild(element);
            return match;
          };
          function type(obj) {
            return obj == null ? String(obj) : class2type[toString.call(obj)] || 'object';
          }
          function isFunction(value) {
            return type(value) == 'function';
          }
          function isWindow(obj) {
            return obj != null && obj == obj.window;
          }
          function isDocument(obj) {
            return obj != null && obj.nodeType == obj.DOCUMENT_NODE;
          }
          function isObject(obj) {
            return type(obj) == 'object';
          }
          function isPlainObject(obj) {
            return (
              isObject(obj) && !isWindow(obj) && Object.getPrototypeOf(obj) == Object.prototype
            );
          }
          function likeArray(obj) {
            var length = !!obj && 'length' in obj && obj.length,
              type = $.type(obj);
            return (
              'function' != type &&
              !isWindow(obj) &&
              ('array' == type ||
                length === 0 ||
                (typeof length == 'number' && length > 0 && length - 1 in obj))
            );
          }
          function compact(array) {
            return filter.call(array, function (item) {
              return item != null;
            });
          }
          function flatten(array) {
            return array.length > 0 ? $.fn.concat.apply([], array) : array;
          }
          camelize = function (str) {
            return str.replace(/-+(.)?/g, function (match, chr) {
              return chr ? chr.toUpperCase() : '';
            });
          };
          function dasherize(str) {
            return str
              .replace(/::/g, '/')
              .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
              .replace(/([a-z\d])([A-Z])/g, '$1_$2')
              .replace(/_/g, '-')
              .toLowerCase();
          }
          uniq = function (array) {
            return filter.call(array, function (item, idx) {
              return array.indexOf(item) == idx;
            });
          };
          function classRE(name) {
            return name in classCache
              ? classCache[name]
              : (classCache[name] = new RegExp('(^|\\s)' + name + '(\\s|$)'));
          }
          function maybeAddPx(name, value) {
            return typeof value == 'number' && !cssNumber[dasherize(name)] ? value + 'px' : value;
          }
          function defaultDisplay(nodeName) {
            var element, display;
            if (!elementDisplay[nodeName]) {
              element = document.createElement(nodeName);
              document.body.appendChild(element);
              display = getComputedStyle(element, '').getPropertyValue('display');
              element.parentNode.removeChild(element);
              display == 'none' && (display = 'block');
              elementDisplay[nodeName] = display;
            }
            return elementDisplay[nodeName];
          }
          function children(element) {
            return 'children' in element
              ? slice.call(element.children)
              : $.map(element.childNodes, function (node) {
                  if (node.nodeType == 1) return node;
                });
          }
          function Z(dom, selector) {
            var i,
              len = dom ? dom.length : 0;
            for (i = 0; i < len; i++) this[i] = dom[i];
            this.length = len;
            this.selector = selector || '';
          }
          zepto.fragment = function (html, name, properties) {
            var dom, nodes, container;
            if (singleTagRE.test(html)) dom = $(document.createElement(RegExp.$1));
            if (!dom) {
              if (html.replace) html = html.replace(tagExpanderRE, '<$1></$2>');
              if (name === undefined) name = fragmentRE.test(html) && RegExp.$1;
              if (!(name in containers)) name = '*';
              container = containers[name];
              container.innerHTML = '' + html;
              dom = $.each(slice.call(container.childNodes), function () {
                container.removeChild(this);
              });
            }
            if (isPlainObject(properties)) {
              nodes = $(dom);
              $.each(properties, function (key, value) {
                if (methodAttributes.indexOf(key) > -1) nodes[key](value);
                else nodes.attr(key, value);
              });
            }
            return dom;
          };
          zepto.Z = function (dom, selector) {
            return new Z(dom, selector);
          };
          zepto.isZ = function (object) {
            return object instanceof zepto.Z;
          };
          zepto.init = function (selector, context) {
            var dom;
            if (!selector) return zepto.Z();
            else if (typeof selector == 'string') {
              selector = selector.trim();
              if (selector[0] == '<' && fragmentRE.test(selector))
                (dom = zepto.fragment(selector, RegExp.$1, context)), (selector = null);
              else if (context !== undefined) return $(context).find(selector);
              else dom = zepto.qsa(document, selector);
            } else if (isFunction(selector)) return $(document).ready(selector);
            else if (zepto.isZ(selector)) return selector;
            else {
              if (isArray(selector)) dom = compact(selector);
              else if (isObject(selector)) (dom = [selector]), (selector = null);
              else if (fragmentRE.test(selector))
                (dom = zepto.fragment(selector.trim(), RegExp.$1, context)), (selector = null);
              else if (context !== undefined) return $(context).find(selector);
              else dom = zepto.qsa(document, selector);
            }
            return zepto.Z(dom, selector);
          };
          $ = function (selector, context) {
            return zepto.init(selector, context);
          };
          function extend(target, source, deep) {
            for (key in source)
              if (deep && (isPlainObject(source[key]) || isArray(source[key]))) {
                if (isPlainObject(source[key]) && !isPlainObject(target[key])) target[key] = {};
                if (isArray(source[key]) && !isArray(target[key])) target[key] = [];
                extend(target[key], source[key], deep);
              } else if (source[key] !== undefined) target[key] = source[key];
          }
          $.extend = function (target) {
            var deep,
              args = slice.call(arguments, 1);
            if (typeof target == 'boolean') {
              deep = target;
              target = args.shift();
            }
            args.forEach(function (arg) {
              extend(target, arg, deep);
            });
            return target;
          };
          zepto.qsa = function (element, selector) {
            var found,
              maybeID = selector[0] == '#',
              maybeClass = !maybeID && selector[0] == '.',
              nameOnly = maybeID || maybeClass ? selector.slice(1) : selector,
              isSimple = simpleSelectorRE.test(nameOnly);
            return element.getElementById && isSimple && maybeID
              ? (found = element.getElementById(nameOnly))
                ? [found]
                : []
              : element.nodeType !== 1 && element.nodeType !== 9 && element.nodeType !== 11
              ? []
              : slice.call(
                  isSimple && !maybeID && element.getElementsByClassName
                    ? maybeClass
                      ? element.getElementsByClassName(nameOnly)
                      : element.getElementsByTagName(selector)
                    : element.querySelectorAll(selector),
                );
          };
          function filtered(nodes, selector) {
            return selector == null ? $(nodes) : $(nodes).filter(selector);
          }
          $.contains = document.documentElement.contains
            ? function (parent, node) {
                return parent !== node && parent.contains(node);
              }
            : function (parent, node) {
                while (node && (node = node.parentNode)) if (node === parent) return true;
                return false;
              };
          function funcArg(context, arg, idx, payload) {
            return isFunction(arg) ? arg.call(context, idx, payload) : arg;
          }
          function setAttribute(node, name, value) {
            value == null ? node.removeAttribute(name) : node.setAttribute(name, value);
          }
          function className(node, value) {
            var klass = node.className || '',
              svg = klass && klass.baseVal !== undefined;
            if (value === undefined) return svg ? klass.baseVal : klass;
            svg ? (klass.baseVal = value) : (node.className = value);
          }
          function deserializeValue(value) {
            try {
              return value
                ? value == 'true' ||
                    (value == 'false'
                      ? false
                      : value == 'null'
                      ? null
                      : +value + '' == value
                      ? +value
                      : /^[\[\{]/.test(value)
                      ? $.parseJSON(value)
                      : value)
                : value;
            } catch (e) {
              return value;
            }
          }
          $.type = type;
          $.isFunction = isFunction;
          $.isWindow = isWindow;
          $.isArray = isArray;
          $.isPlainObject = isPlainObject;
          $.isEmptyObject = function (obj) {
            var name;
            for (name in obj) return false;
            return true;
          };
          $.isNumeric = function (val) {
            var num = Number(val),
              type = typeof val;
            return (
              (val != null &&
                type != 'boolean' &&
                (type != 'string' || val.length) &&
                !isNaN(num) &&
                isFinite(num)) ||
              false
            );
          };
          $.inArray = function (elem, array, i) {
            return emptyArray.indexOf.call(array, elem, i);
          };
          $.camelCase = camelize;
          $.trim = function (str) {
            return str == null ? '' : String.prototype.trim.call(str);
          };
          $.uuid = 0;
          $.support = {};
          $.expr = {};
          $.noop = function () {};
          $.map = function (elements, callback) {
            var value,
              values = [],
              i,
              key;
            if (likeArray(elements))
              for (i = 0; i < elements.length; i++) {
                value = callback(elements[i], i);
                if (value != null) values.push(value);
              }
            else
              for (key in elements) {
                value = callback(elements[key], key);
                if (value != null) values.push(value);
              }
            return flatten(values);
          };
          $.each = function (elements, callback) {
            var i, key;
            if (likeArray(elements)) {
              for (i = 0; i < elements.length; i++)
                if (callback.call(elements[i], i, elements[i]) === false) return elements;
            } else {
              for (key in elements)
                if (callback.call(elements[key], key, elements[key]) === false) return elements;
            }
            return elements;
          };
          $.grep = function (elements, callback) {
            return filter.call(elements, callback);
          };
          if (window.JSON) $.parseJSON = JSON.parse;
          $.each(
            'Boolean Number String Function Array Date RegExp Object Error'.split(' '),
            function (i, name) {
              class2type['[object ' + name + ']'] = name.toLowerCase();
            },
          );
          $.fn = {
            constructor: zepto.Z,
            length: 0,
            forEach: emptyArray.forEach,
            reduce: emptyArray.reduce,
            push: emptyArray.push,
            sort: emptyArray.sort,
            splice: emptyArray.splice,
            indexOf: emptyArray.indexOf,
            concat: function () {
              var i,
                value,
                args = [];
              for (i = 0; i < arguments.length; i++) {
                value = arguments[i];
                args[i] = zepto.isZ(value) ? value.toArray() : value;
              }
              return concat.apply(zepto.isZ(this) ? this.toArray() : this, args);
            },
            map: function (fn) {
              return $(
                $.map(this, function (el, i) {
                  return fn.call(el, i, el);
                }),
              );
            },
            slice: function () {
              return $(slice.apply(this, arguments));
            },
            ready: function (callback) {
              if (readyRE.test(document.readyState) && document.body) callback($);
              else
                document.addEventListener(
                  'DOMContentLoaded',
                  function () {
                    callback($);
                  },
                  false,
                );
              return this;
            },
            get: function (idx) {
              return idx === undefined
                ? slice.call(this)
                : this[idx >= 0 ? idx : idx + this.length];
            },
            toArray: function () {
              return this.get();
            },
            size: function () {
              return this.length;
            },
            remove: function () {
              return this.each(function () {
                if (this.parentNode != null) this.parentNode.removeChild(this);
              });
            },
            each: function (callback) {
              emptyArray.every.call(this, function (el, idx) {
                return callback.call(el, idx, el) !== false;
              });
              return this;
            },
            filter: function (selector) {
              if (isFunction(selector)) return this.not(this.not(selector));
              return $(
                filter.call(this, function (element) {
                  return zepto.matches(element, selector);
                }),
              );
            },
            add: function (selector, context) {
              return $(uniq(this.concat($(selector, context))));
            },
            is: function (selector) {
              return this.length > 0 && zepto.matches(this[0], selector);
            },
            not: function (selector) {
              var nodes = [];
              if (isFunction(selector) && selector.call !== undefined)
                this.each(function (idx) {
                  if (!selector.call(this, idx)) nodes.push(this);
                });
              else {
                var excludes =
                  typeof selector == 'string'
                    ? this.filter(selector)
                    : likeArray(selector) && isFunction(selector.item)
                    ? slice.call(selector)
                    : $(selector);
                this.forEach(function (el) {
                  if (excludes.indexOf(el) < 0) nodes.push(el);
                });
              }
              return $(nodes);
            },
            has: function (selector) {
              return this.filter(function () {
                return isObject(selector)
                  ? $.contains(this, selector)
                  : $(this).find(selector).size();
              });
            },
            eq: function (idx) {
              return idx === -1 ? this.slice(idx) : this.slice(idx, +idx + 1);
            },
            first: function () {
              var el = this[0];
              return el && !isObject(el) ? el : $(el);
            },
            last: function () {
              var el = this[this.length - 1];
              return el && !isObject(el) ? el : $(el);
            },
            find: function (selector) {
              var result,
                $this = this;
              if (!selector) result = $();
              else if (typeof selector == 'object')
                result = $(selector).filter(function () {
                  var node = this;
                  return emptyArray.some.call($this, function (parent) {
                    return $.contains(parent, node);
                  });
                });
              else if (this.length == 1) result = $(zepto.qsa(this[0], selector));
              else
                result = this.map(function () {
                  return zepto.qsa(this, selector);
                });
              return result;
            },
            closest: function (selector, context) {
              var nodes = [],
                collection = typeof selector == 'object' && $(selector);
              this.each(function (_, node) {
                while (
                  node &&
                  !(collection ? collection.indexOf(node) >= 0 : zepto.matches(node, selector))
                )
                  node = node !== context && !isDocument(node) && node.parentNode;
                if (node && nodes.indexOf(node) < 0) nodes.push(node);
              });
              return $(nodes);
            },
            parents: function (selector) {
              var ancestors = [],
                nodes = this;
              while (nodes.length > 0)
                nodes = $.map(nodes, function (node) {
                  if (
                    (node = node.parentNode) &&
                    !isDocument(node) &&
                    ancestors.indexOf(node) < 0
                  ) {
                    ancestors.push(node);
                    return node;
                  }
                });
              return filtered(ancestors, selector);
            },
            parent: function (selector) {
              return filtered(uniq(this.pluck('parentNode')), selector);
            },
            children: function (selector) {
              return filtered(
                this.map(function () {
                  return children(this);
                }),
                selector,
              );
            },
            contents: function () {
              return this.map(function () {
                return this.contentDocument || slice.call(this.childNodes);
              });
            },
            siblings: function (selector) {
              return filtered(
                this.map(function (i, el) {
                  return filter.call(children(el.parentNode), function (child) {
                    return child !== el;
                  });
                }),
                selector,
              );
            },
            empty: function () {
              return this.each(function () {
                this.innerHTML = '';
              });
            },
            pluck: function (property) {
              return $.map(this, function (el) {
                return el[property];
              });
            },
            show: function () {
              return this.each(function () {
                this.style.display == 'none' && (this.style.display = '');
                if (getComputedStyle(this, '').getPropertyValue('display') == 'none')
                  this.style.display = defaultDisplay(this.nodeName);
              });
            },
            replaceWith: function (newContent) {
              return this.before(newContent).remove();
            },
            wrap: function (structure) {
              var func = isFunction(structure);
              if (this[0] && !func)
                var dom = $(structure).get(0),
                  clone = dom.parentNode || this.length > 1;
              return this.each(function (index) {
                $(this).wrapAll(
                  func ? structure.call(this, index) : clone ? dom.cloneNode(true) : dom,
                );
              });
            },
            wrapAll: function (structure) {
              if (this[0]) {
                $(this[0]).before((structure = $(structure)));
                var children;
                while ((children = structure.children()).length) structure = children.first();
                $(structure).append(this);
              }
              return this;
            },
            wrapInner: function (structure) {
              var func = isFunction(structure);
              return this.each(function (index) {
                var self = $(this),
                  contents = self.contents(),
                  dom = func ? structure.call(this, index) : structure;
                contents.length ? contents.wrapAll(dom) : self.append(dom);
              });
            },
            unwrap: function () {
              this.parent().each(function () {
                $(this).replaceWith($(this).children());
              });
              return this;
            },
            clone: function () {
              return this.map(function () {
                return this.cloneNode(true);
              });
            },
            hide: function () {
              return this.css('display', 'none');
            },
            toggle: function (setting) {
              return this.each(function () {
                var el = $(this);
                (setting === undefined ? el.css('display') == 'none' : setting)
                  ? el.show()
                  : el.hide();
              });
            },
            prev: function (selector) {
              return $(this.pluck('previousElementSibling')).filter(selector || '*');
            },
            next: function (selector) {
              return $(this.pluck('nextElementSibling')).filter(selector || '*');
            },
            html: function (html) {
              return 0 in arguments
                ? this.each(function (idx) {
                    var originHtml = this.innerHTML;
                    $(this).empty().append(funcArg(this, html, idx, originHtml));
                  })
                : 0 in this
                ? this[0].innerHTML
                : null;
            },
            text: function (text) {
              return 0 in arguments
                ? this.each(function (idx) {
                    var newText = funcArg(this, text, idx, this.textContent);
                    this.textContent = newText == null ? '' : '' + newText;
                  })
                : 0 in this
                ? this.pluck('textContent').join('')
                : null;
            },
            attr: function (name, value) {
              var result;
              return typeof name == 'string' && !(1 in arguments)
                ? 0 in this &&
                  this[0].nodeType == 1 &&
                  (result = this[0].getAttribute(name)) != null
                  ? result
                  : undefined
                : this.each(function (idx) {
                    if (this.nodeType !== 1) return;
                    if (isObject(name)) for (key in name) setAttribute(this, key, name[key]);
                    else
                      setAttribute(this, name, funcArg(this, value, idx, this.getAttribute(name)));
                  });
            },
            removeAttr: function (name) {
              return this.each(function () {
                this.nodeType === 1 &&
                  name.split(' ').forEach(function (attribute) {
                    setAttribute(this, attribute);
                  }, this);
              });
            },
            prop: function (name, value) {
              name = propMap[name] || name;
              return 1 in arguments
                ? this.each(function (idx) {
                    this[name] = funcArg(this, value, idx, this[name]);
                  })
                : this[0] && this[0][name];
            },
            removeProp: function (name) {
              name = propMap[name] || name;
              return this.each(function () {
                delete this[name];
              });
            },
            data: function (name, value) {
              var attrName = 'data-' + name.replace(capitalRE, '-$1').toLowerCase();
              var data = 1 in arguments ? this.attr(attrName, value) : this.attr(attrName);
              return data !== null ? deserializeValue(data) : undefined;
            },
            val: function (value) {
              if (0 in arguments) {
                if (value == null) value = '';
                return this.each(function (idx) {
                  this.value = funcArg(this, value, idx, this.value);
                });
              } else {
                return (
                  this[0] &&
                  (this[0].multiple
                    ? $(this[0])
                        .find('option')
                        .filter(function () {
                          return this.selected;
                        })
                        .pluck('value')
                    : this[0].value)
                );
              }
            },
            offset: function (coordinates) {
              if (coordinates)
                return this.each(function (index) {
                  var $this = $(this),
                    coords = funcArg(this, coordinates, index, $this.offset()),
                    parentOffset = $this.offsetParent().offset(),
                    props = {
                      top: coords.top - parentOffset.top,
                      left: coords.left - parentOffset.left,
                    };
                  if ($this.css('position') == 'static') props['position'] = 'relative';
                  $this.css(props);
                });
              if (!this.length) return null;
              if (
                document.documentElement !== this[0] &&
                !$.contains(document.documentElement, this[0])
              )
                return { top: 0, left: 0 };
              var obj = this[0].getBoundingClientRect();
              return {
                left: obj.left + window.pageXOffset,
                top: obj.top + window.pageYOffset,
                width: Math.round(obj.width),
                height: Math.round(obj.height),
              };
            },
            css: function (property, value) {
              if (arguments.length < 2) {
                var element = this[0];
                if (typeof property == 'string') {
                  if (!element) return;
                  return (
                    element.style[camelize(property)] ||
                    getComputedStyle(element, '').getPropertyValue(property)
                  );
                } else if (isArray(property)) {
                  if (!element) return;
                  var props = {};
                  var computedStyle = getComputedStyle(element, '');
                  $.each(property, function (_, prop) {
                    props[prop] =
                      element.style[camelize(prop)] || computedStyle.getPropertyValue(prop);
                  });
                  return props;
                }
              }
              var css = '';
              if (type(property) == 'string') {
                if (!value && value !== 0)
                  this.each(function () {
                    this.style.removeProperty(dasherize(property));
                  });
                else css = dasherize(property) + ':' + maybeAddPx(property, value);
              } else {
                for (key in property)
                  if (!property[key] && property[key] !== 0)
                    this.each(function () {
                      this.style.removeProperty(dasherize(key));
                    });
                  else css += dasherize(key) + ':' + maybeAddPx(key, property[key]) + ';';
              }
              return this.each(function () {
                this.style.cssText += ';' + css;
              });
            },
            index: function (element) {
              return element
                ? this.indexOf($(element)[0])
                : this.parent().children().indexOf(this[0]);
            },
            hasClass: function (name) {
              if (!name) return false;
              return emptyArray.some.call(
                this,
                function (el) {
                  return this.test(className(el));
                },
                classRE(name),
              );
            },
            addClass: function (name) {
              if (!name) return this;
              return this.each(function (idx) {
                if (!('className' in this)) return;
                classList = [];
                var cls = className(this),
                  newName = funcArg(this, name, idx, cls);
                newName.split(/\s+/g).forEach(function (klass) {
                  if (!$(this).hasClass(klass)) classList.push(klass);
                }, this);
                classList.length && className(this, cls + (cls ? ' ' : '') + classList.join(' '));
              });
            },
            removeClass: function (name) {
              return this.each(function (idx) {
                if (!('className' in this)) return;
                if (name === undefined) return className(this, '');
                classList = className(this);
                funcArg(this, name, idx, classList)
                  .split(/\s+/g)
                  .forEach(function (klass) {
                    classList = classList.replace(classRE(klass), ' ');
                  });
                className(this, classList.trim());
              });
            },
            toggleClass: function (name, when) {
              if (!name) return this;
              return this.each(function (idx) {
                var $this = $(this),
                  names = funcArg(this, name, idx, className(this));
                names.split(/\s+/g).forEach(function (klass) {
                  (when === undefined ? !$this.hasClass(klass) : when)
                    ? $this.addClass(klass)
                    : $this.removeClass(klass);
                });
              });
            },
            scrollTop: function (value) {
              if (!this.length) return;
              var hasScrollTop = 'scrollTop' in this[0];
              if (value === undefined)
                return hasScrollTop ? this[0].scrollTop : this[0].pageYOffset;
              return this.each(
                hasScrollTop
                  ? function () {
                      this.scrollTop = value;
                    }
                  : function () {
                      this.scrollTo(this.scrollX, value);
                    },
              );
            },
            scrollLeft: function (value) {
              if (!this.length) return;
              var hasScrollLeft = 'scrollLeft' in this[0];
              if (value === undefined)
                return hasScrollLeft ? this[0].scrollLeft : this[0].pageXOffset;
              return this.each(
                hasScrollLeft
                  ? function () {
                      this.scrollLeft = value;
                    }
                  : function () {
                      this.scrollTo(value, this.scrollY);
                    },
              );
            },
            position: function () {
              if (!this.length) return;
              var elem = this[0],
                offsetParent = this.offsetParent(),
                offset = this.offset(),
                parentOffset = rootNodeRE.test(offsetParent[0].nodeName)
                  ? { top: 0, left: 0 }
                  : offsetParent.offset();
              offset.top -= parseFloat($(elem).css('margin-top')) || 0;
              offset.left -= parseFloat($(elem).css('margin-left')) || 0;
              parentOffset.top += parseFloat($(offsetParent[0]).css('border-top-width')) || 0;
              parentOffset.left += parseFloat($(offsetParent[0]).css('border-left-width')) || 0;
              return { top: offset.top - parentOffset.top, left: offset.left - parentOffset.left };
            },
            offsetParent: function () {
              return this.map(function () {
                var parent = this.offsetParent || document.body;
                while (
                  parent &&
                  !rootNodeRE.test(parent.nodeName) &&
                  $(parent).css('position') == 'static'
                )
                  parent = parent.offsetParent;
                return parent;
              });
            },
          };
          $.fn.detach = $.fn.remove;
          ['width', 'height'].forEach(function (dimension) {
            var dimensionProperty = dimension.replace(/./, function (m) {
              return m[0].toUpperCase();
            });
            $.fn[dimension] = function (value) {
              var offset,
                el = this[0];
              if (value === undefined)
                return isWindow(el)
                  ? el['inner' + dimensionProperty]
                  : isDocument(el)
                  ? el.documentElement['scroll' + dimensionProperty]
                  : (offset = this.offset()) && offset[dimension];
              else
                return this.each(function (idx) {
                  el = $(this);
                  el.css(dimension, funcArg(this, value, idx, el[dimension]()));
                });
            };
          });
          function traverseNode(node, fun) {
            fun(node);
            for (var i = 0, len = node.childNodes.length; i < len; i++)
              traverseNode(node.childNodes[i], fun);
          }
          adjacencyOperators.forEach(function (operator, operatorIndex) {
            var inside = operatorIndex % 2;
            $.fn[operator] = function () {
              var argType,
                nodes = $.map(arguments, function (arg) {
                  var arr = [];
                  argType = type(arg);
                  if (argType == 'array') {
                    arg.forEach(function (el) {
                      if (el.nodeType !== undefined) return arr.push(el);
                      else if ($.zepto.isZ(el)) return (arr = arr.concat(el.get()));
                      arr = arr.concat(zepto.fragment(el));
                    });
                    return arr;
                  }
                  return argType == 'object' || arg == null ? arg : zepto.fragment(arg);
                }),
                parent,
                copyByClone = this.length > 1;
              if (nodes.length < 1) return this;
              return this.each(function (_, target) {
                parent = inside ? target : target.parentNode;
                target =
                  operatorIndex == 0
                    ? target.nextSibling
                    : operatorIndex == 1
                    ? target.firstChild
                    : operatorIndex == 2
                    ? target
                    : null;
                var parentInDocument = $.contains(document.documentElement, parent);
                nodes.forEach(function (node) {
                  if (copyByClone) node = node.cloneNode(true);
                  else if (!parent) return $(node).remove();
                  parent.insertBefore(node, target);
                  if (parentInDocument)
                    traverseNode(node, function (el) {
                      if (
                        el.nodeName != null &&
                        el.nodeName.toUpperCase() === 'SCRIPT' &&
                        (!el.type || el.type === 'text/javascript') &&
                        !el.src
                      ) {
                        var target = el.ownerDocument ? el.ownerDocument.defaultView : window;
                        target['eval'].call(target, el.innerHTML);
                      }
                    });
                });
              });
            };
            $.fn[inside ? operator + 'To' : 'insert' + (operatorIndex ? 'Before' : 'After')] =
              function (html) {
                $(html)[operator](this);
                return this;
              };
          });
          zepto.Z.prototype = Z.prototype = $.fn;
          zepto.uniq = uniq;
          zepto.deserializeValue = deserializeValue;
          $.zepto = zepto;
          return $;
        })();
        (function ($) {
          var _zid = 1,
            undefined,
            slice = Array.prototype.slice,
            isFunction = $.isFunction,
            isString = function (obj) {
              return typeof obj == 'string';
            },
            handlers = {},
            specialEvents = {},
            focusinSupported = 'onfocusin' in window,
            focus = { focus: 'focusin', blur: 'focusout' },
            hover = { mouseenter: 'mouseover', mouseleave: 'mouseout' };
          specialEvents.click =
            specialEvents.mousedown =
            specialEvents.mouseup =
            specialEvents.mousemove =
              'MouseEvents';
          function zid(element) {
            return element._zid || (element._zid = _zid++);
          }
          function findHandlers(element, event, fn, selector) {
            event = parse(event);
            if (event.ns) var matcher = matcherFor(event.ns);
            return (handlers[zid(element)] || []).filter(function (handler) {
              return (
                handler &&
                (!event.e || handler.e == event.e) &&
                (!event.ns || matcher.test(handler.ns)) &&
                (!fn || zid(handler.fn) === zid(fn)) &&
                (!selector || handler.sel == selector)
              );
            });
          }
          function parse(event) {
            var parts = ('' + event).split('.');
            return { e: parts[0], ns: parts.slice(1).sort().join(' ') };
          }
          function matcherFor(ns) {
            return new RegExp('(?:^| )' + ns.replace(' ', ' .* ?') + '(?: |$)');
          }
          function eventCapture(handler, captureSetting) {
            return (handler.del && !focusinSupported && handler.e in focus) || !!captureSetting;
          }
          function realEvent(type) {
            return hover[type] || (focusinSupported && focus[type]) || type;
          }
          function add(element, events, fn, data, selector, delegator, capture) {
            var id = zid(element),
              set = handlers[id] || (handlers[id] = []);
            events.split(/\s/).forEach(function (event) {
              if (event == 'ready') return $(document).ready(fn);
              var handler = parse(event);
              handler.fn = fn;
              handler.sel = selector;
              if (handler.e in hover)
                fn = function (e) {
                  var related = e.relatedTarget;
                  if (!related || (related !== this && !$.contains(this, related)))
                    return handler.fn.apply(this, arguments);
                };
              handler.del = delegator;
              var callback = delegator || fn;
              handler.proxy = function (e) {
                e = compatible(e);
                if (e.isImmediatePropagationStopped()) return;
                try {
                  var dataPropDescriptor = Object.getOwnPropertyDescriptor(e, 'data');
                  if (!dataPropDescriptor || dataPropDescriptor.writable) e.data = data;
                } catch (e) {}
                var result = callback.apply(
                  element,
                  e._args == undefined ? [e] : [e].concat(e._args),
                );
                if (result === false) e.preventDefault(), e.stopPropagation();
                return result;
              };
              handler.i = set.length;
              set.push(handler);
              if ('addEventListener' in element)
                element.addEventListener(
                  realEvent(handler.e),
                  handler.proxy,
                  eventCapture(handler, capture),
                );
            });
          }
          function remove(element, events, fn, selector, capture) {
            var id = zid(element);
            (events || '').split(/\s/).forEach(function (event) {
              findHandlers(element, event, fn, selector).forEach(function (handler) {
                delete handlers[id][handler.i];
                if ('removeEventListener' in element)
                  element.removeEventListener(
                    realEvent(handler.e),
                    handler.proxy,
                    eventCapture(handler, capture),
                  );
              });
            });
          }
          $.event = { add: add, remove: remove };
          $.proxy = function (fn, context) {
            var args = 2 in arguments && slice.call(arguments, 2);
            if (isFunction(fn)) {
              var proxyFn = function () {
                return fn.apply(context, args ? args.concat(slice.call(arguments)) : arguments);
              };
              proxyFn._zid = zid(fn);
              return proxyFn;
            } else if (isString(context)) {
              if (args) {
                args.unshift(fn[context], fn);
                return $.proxy.apply(null, args);
              } else {
                return $.proxy(fn[context], fn);
              }
            } else {
              throw new TypeError('expected function');
            }
          };
          $.fn.bind = function (event, data, callback) {
            return this.on(event, data, callback);
          };
          $.fn.unbind = function (event, callback) {
            return this.off(event, callback);
          };
          $.fn.one = function (event, selector, data, callback) {
            return this.on(event, selector, data, callback, 1);
          };
          var returnTrue = function () {
              return true;
            },
            returnFalse = function () {
              return false;
            },
            ignoreProperties = /^([A-Z]|returnValue$|layer[XY]$|webkitMovement[XY]$)/,
            eventMethods = {
              preventDefault: 'isDefaultPrevented',
              stopImmediatePropagation: 'isImmediatePropagationStopped',
              stopPropagation: 'isPropagationStopped',
            };
          function compatible(event, source) {
            if (source || !event.isDefaultPrevented) {
              source || (source = event);
              $.each(eventMethods, function (name, predicate) {
                var sourceMethod = source[name];
                event[name] = function () {
                  this[predicate] = returnTrue;
                  return sourceMethod && sourceMethod.apply(source, arguments);
                };
                event[predicate] = returnFalse;
              });
              event.timeStamp || (event.timeStamp = Date.now());
              if (
                source.defaultPrevented !== undefined
                  ? source.defaultPrevented
                  : 'returnValue' in source
                  ? source.returnValue === false
                  : source.getPreventDefault && source.getPreventDefault()
              )
                event.isDefaultPrevented = returnTrue;
            }
            return event;
          }
          function createProxy(event) {
            var key,
              proxy = { originalEvent: event };
            for (key in event)
              if (!ignoreProperties.test(key) && event[key] !== undefined) proxy[key] = event[key];
            return compatible(proxy, event);
          }
          $.fn.delegate = function (selector, event, callback) {
            return this.on(event, selector, callback);
          };
          $.fn.undelegate = function (selector, event, callback) {
            return this.off(event, selector, callback);
          };
          $.fn.live = function (event, callback) {
            $(document.body).delegate(this.selector, event, callback);
            return this;
          };
          $.fn.die = function (event, callback) {
            $(document.body).undelegate(this.selector, event, callback);
            return this;
          };
          $.fn.on = function (event, selector, data, callback, one) {
            var autoRemove,
              delegator,
              $this = this;
            if (event && !isString(event)) {
              $.each(event, function (type, fn) {
                $this.on(type, selector, data, fn, one);
              });
              return $this;
            }
            if (!isString(selector) && !isFunction(callback) && callback !== false)
              (callback = data), (data = selector), (selector = undefined);
            if (callback === undefined || data === false) (callback = data), (data = undefined);
            if (callback === false) callback = returnFalse;
            return $this.each(function (_, element) {
              if (one)
                autoRemove = function (e) {
                  remove(element, e.type, callback);
                  return callback.apply(this, arguments);
                };
              if (selector)
                delegator = function (e) {
                  var evt,
                    match = $(e.target).closest(selector, element).get(0);
                  if (match && match !== element) {
                    evt = $.extend(createProxy(e), { currentTarget: match, liveFired: element });
                    return (autoRemove || callback).apply(
                      match,
                      [evt].concat(slice.call(arguments, 1)),
                    );
                  }
                };
              add(element, event, callback, data, selector, delegator || autoRemove);
            });
          };
          $.fn.off = function (event, selector, callback) {
            var $this = this;
            if (event && !isString(event)) {
              $.each(event, function (type, fn) {
                $this.off(type, selector, fn);
              });
              return $this;
            }
            if (!isString(selector) && !isFunction(callback) && callback !== false)
              (callback = selector), (selector = undefined);
            if (callback === false) callback = returnFalse;
            return $this.each(function () {
              remove(this, event, callback, selector);
            });
          };
          $.fn.trigger = function (event, args) {
            event = isString(event) || $.isPlainObject(event) ? $.Event(event) : compatible(event);
            event._args = args;
            return this.each(function () {
              if (event.type in focus && typeof this[event.type] == 'function') this[event.type]();
              else if ('dispatchEvent' in this) this.dispatchEvent(event);
              else $(this).triggerHandler(event, args);
            });
          };
          $.fn.triggerHandler = function (event, args) {
            var e, result;
            this.each(function (i, element) {
              e = createProxy(isString(event) ? $.Event(event) : event);
              e._args = args;
              e.target = element;
              $.each(findHandlers(element, event.type || event), function (i, handler) {
                result = handler.proxy(e);
                if (e.isImmediatePropagationStopped()) return false;
              });
            });
            return result;
          };
          (
            'focusin focusout focus blur load resize scroll unload click dblclick ' +
            'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave ' +
            'change select keydown keypress keyup error'
          )
            .split(' ')
            .forEach(function (event) {
              $.fn[event] = function (callback) {
                return 0 in arguments ? this.bind(event, callback) : this.trigger(event);
              };
            });
          $.Event = function (type, props) {
            if (!isString(type)) (props = type), (type = props.type);
            var event = document.createEvent(specialEvents[type] || 'Events'),
              bubbles = true;
            if (props)
              for (var name in props)
                name == 'bubbles' ? (bubbles = !!props[name]) : (event[name] = props[name]);
            event.initEvent(type, bubbles, true);
            return compatible(event);
          };
        })(Zepto);
        (function ($) {
          var cache = [],
            timeout;
          $.fn.remove = function () {
            return this.each(function () {
              if (this.parentNode) {
                if (this.tagName === 'IMG') {
                  cache.push(this);
                  this.src = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=';
                  if (timeout) clearTimeout(timeout);
                  timeout = setTimeout(function () {
                    cache = [];
                  }, 6e4);
                }
                this.parentNode.removeChild(this);
              }
            });
          };
        })(Zepto);
        (function ($) {
          var data = {},
            dataAttr = $.fn.data,
            camelize = $.camelCase,
            exp = ($.expando = 'Zepto' + +new Date()),
            emptyArray = [];
          function getData(node, name) {
            var id = node[exp],
              store = id && data[id];
            if (name === undefined) return store || setData(node);
            else {
              if (store) {
                if (name in store) return store[name];
                var camelName = camelize(name);
                if (camelName in store) return store[camelName];
              }
              return dataAttr.call($(node), name);
            }
          }
          function setData(node, name, value) {
            var id = node[exp] || (node[exp] = ++$.uuid),
              store = data[id] || (data[id] = attributeData(node));
            if (name !== undefined) store[camelize(name)] = value;
            return store;
          }
          function attributeData(node) {
            var store = {};
            $.each(node.attributes || emptyArray, function (i, attr) {
              if (attr.name.indexOf('data-') == 0)
                store[camelize(attr.name.replace('data-', ''))] = $.zepto.deserializeValue(
                  attr.value,
                );
            });
            return store;
          }
          $.fn.data = function (name, value) {
            return value === undefined
              ? $.isPlainObject(name)
                ? this.each(function (i, node) {
                    $.each(name, function (key, value) {
                      setData(node, key, value);
                    });
                  })
                : 0 in this
                ? getData(this[0], name)
                : undefined
              : this.each(function () {
                  setData(this, name, value);
                });
          };
          $.data = function (elem, name, value) {
            return $(elem).data(name, value);
          };
          $.hasData = function (elem) {
            var id = elem[exp],
              store = id && data[id];
            return store ? !$.isEmptyObject(store) : false;
          };
          $.fn.removeData = function (names) {
            if (typeof names == 'string') names = names.split(/\s+/);
            return this.each(function () {
              var id = this[exp],
                store = id && data[id];
              if (store)
                $.each(names || store, function (key) {
                  delete store[names ? camelize(this) : key];
                });
            });
          };
          ['remove', 'empty'].forEach(function (methodName) {
            var origFn = $.fn[methodName];
            $.fn[methodName] = function () {
              var elements = this.find('*');
              if (methodName === 'remove') elements = elements.add(this);
              elements.removeData();
              return origFn.call(this);
            };
          });
        })(Zepto);
        return Zepto;
      });
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var namespace = 'autocomplete:';
      var _ = __webpack_require__(0);
      var DOM = __webpack_require__(1);
      function EventBus(o) {
        if (!o || !o.el) {
          _.error('EventBus initialized without el');
        }
        this.$el = DOM.element(o.el);
      }
      _.mixin(EventBus.prototype, {
        trigger: function (type, suggestion, dataset, context) {
          var event = _.Event(namespace + type);
          this.$el.trigger(event, [suggestion, dataset, context]);
          return event;
        },
      });
      module.exports = EventBus;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      module.exports = {
        wrapper: '<span class="%ROOT%"></span>',
        dropdown: '<span class="%PREFIX%%DROPDOWN_MENU%"></span>',
        dataset: '<div class="%PREFIX%%DATASET%-%CLASS%"></div>',
        suggestions: '<span class="%PREFIX%%SUGGESTIONS%"></span>',
        suggestion: '<div class="%PREFIX%%SUGGESTION%"></div>',
      };
    },
    function (module, exports) {
      module.exports = '0.36.0';
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      module.exports = function parseAlgoliaClientVersion(agent) {
        var parsed = agent.match(/Algolia for vanilla JavaScript (\d+\.)(\d+\.)(\d+)/);
        if (parsed) return [parsed[1], parsed[2], parsed[3]];
        return undefined;
      };
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      Object.defineProperty(exports, '__esModule', { value: true });
      var _zepto = __webpack_require__(15);
      var _zepto2 = _interopRequireDefault(_zepto);
      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }
      exports.default = _zepto2.default;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      Object.defineProperty(exports, '__esModule', { value: true });
      exports.default = '2.6.3';
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var _main = __webpack_require__(23);
      var _main2 = _interopRequireDefault(_main);
      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }
      module.exports = _main2.default;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      Object.defineProperty(exports, '__esModule', { value: true });
      var _toFactory = __webpack_require__(24);
      var _toFactory2 = _interopRequireDefault(_toFactory);
      var _DocSearch = __webpack_require__(25);
      var _DocSearch2 = _interopRequireDefault(_DocSearch);
      var _version = __webpack_require__(21);
      var _version2 = _interopRequireDefault(_version);
      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }
      var docsearch = (0, _toFactory2.default)(_DocSearch2.default);
      docsearch.version = _version2.default;
      exports.default = docsearch;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var _bind = Function.prototype.bind;
      function toFactory(Class) {
        var Factory = function Factory() {
          for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
          return new (_bind.apply(Class, [null].concat(args)))();
        };
        Factory.__proto__ = Class;
        Factory.prototype = Class.prototype;
        return Factory;
      }
      module.exports = toFactory;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      Object.defineProperty(exports, '__esModule', { value: true });
      var _extends =
        Object.assign ||
        function (target) {
          for (var i = 1; i < arguments.length; i++) {
            var source = arguments[i];
            for (var key in source) {
              if (Object.prototype.hasOwnProperty.call(source, key)) {
                target[key] = source[key];
              }
            }
          }
          return target;
        };
      var _createClass = (function () {
        function defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ('value' in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }
        return function (Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      })();
      var _hogan = __webpack_require__(26);
      var _hogan2 = _interopRequireDefault(_hogan);
      var _lite = __webpack_require__(29);
      var _lite2 = _interopRequireDefault(_lite);
      var _autocomplete = __webpack_require__(49);
      var _autocomplete2 = _interopRequireDefault(_autocomplete);
      var _templates = __webpack_require__(64);
      var _templates2 = _interopRequireDefault(_templates);
      var _utils = __webpack_require__(65);
      var _utils2 = _interopRequireDefault(_utils);
      var _version = __webpack_require__(21);
      var _version2 = _interopRequireDefault(_version);
      var _zepto = __webpack_require__(20);
      var _zepto2 = _interopRequireDefault(_zepto);
      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }
      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError('Cannot call a class as a function');
        }
      }
      var usage =
        'Usage:\n  documentationSearch({\n  apiKey,\n  indexName,\n  inputSelector,\n  [ appId ],\n  [ algoliaOptions.{hitsPerPage} ]\n  [ autocompleteOptions.{hint,debug} ]\n})';
      var DocSearch = (function () {
        function DocSearch(_ref) {
          var apiKey = _ref.apiKey,
            indexName = _ref.indexName,
            inputSelector = _ref.inputSelector,
            _ref$appId = _ref.appId,
            appId = _ref$appId === undefined ? 'BH4D9OD16A' : _ref$appId,
            _ref$debug = _ref.debug,
            debug = _ref$debug === undefined ? false : _ref$debug,
            _ref$algoliaOptions = _ref.algoliaOptions,
            algoliaOptions = _ref$algoliaOptions === undefined ? {} : _ref$algoliaOptions,
            _ref$queryDataCallbac = _ref.queryDataCallback,
            queryDataCallback = _ref$queryDataCallbac === undefined ? null : _ref$queryDataCallbac,
            _ref$autocompleteOpti = _ref.autocompleteOptions,
            autocompleteOptions =
              _ref$autocompleteOpti === undefined
                ? { debug: false, hint: false, autoselect: true }
                : _ref$autocompleteOpti,
            _ref$transformData = _ref.transformData,
            transformData = _ref$transformData === undefined ? false : _ref$transformData,
            _ref$queryHook = _ref.queryHook,
            queryHook = _ref$queryHook === undefined ? false : _ref$queryHook,
            _ref$handleSelected = _ref.handleSelected,
            handleSelected = _ref$handleSelected === undefined ? false : _ref$handleSelected,
            _ref$enhancedSearchIn = _ref.enhancedSearchInput,
            enhancedSearchInput =
              _ref$enhancedSearchIn === undefined ? false : _ref$enhancedSearchIn,
            _ref$layout = _ref.layout,
            layout = _ref$layout === undefined ? 'collumns' : _ref$layout;
          _classCallCheck(this, DocSearch);
          DocSearch.checkArguments({
            apiKey: apiKey,
            indexName: indexName,
            inputSelector: inputSelector,
            debug: debug,
            algoliaOptions: algoliaOptions,
            queryDataCallback: queryDataCallback,
            autocompleteOptions: autocompleteOptions,
            transformData: transformData,
            queryHook: queryHook,
            handleSelected: handleSelected,
            enhancedSearchInput: enhancedSearchInput,
            layout: layout,
          });
          this.apiKey = apiKey;
          this.appId = appId;
          this.indexName = indexName;
          this.input = DocSearch.getInputFromSelector(inputSelector);
          this.algoliaOptions = _extends({ hitsPerPage: 5 }, algoliaOptions);
          this.queryDataCallback = queryDataCallback || null;
          var autocompleteOptionsDebug =
            autocompleteOptions && autocompleteOptions.debug ? autocompleteOptions.debug : false;
          autocompleteOptions.debug = debug || autocompleteOptionsDebug;
          this.autocompleteOptions = autocompleteOptions;
          this.autocompleteOptions.cssClasses = this.autocompleteOptions.cssClasses || {};
          this.autocompleteOptions.cssClasses.prefix =
            this.autocompleteOptions.cssClasses.prefix || 'ds';
          var inputAriaLabel =
            this.input && typeof this.input.attr === 'function' && this.input.attr('aria-label');
          this.autocompleteOptions.ariaLabel =
            this.autocompleteOptions.ariaLabel || inputAriaLabel || 'search input';
          this.isSimpleLayout = layout === 'simple';
          this.client = (0, _lite2.default)(this.appId, this.apiKey);
          this.client.addAlgoliaAgent('docsearch.js ' + _version2.default);
          if (enhancedSearchInput) {
            this.input = DocSearch.injectSearchBox(this.input);
          }
          this.autocomplete = (0, _autocomplete2.default)(this.input, autocompleteOptions, [
            {
              source: this.getAutocompleteSource(transformData, queryHook),
              templates: {
                suggestion: DocSearch.getSuggestionTemplate(this.isSimpleLayout),
                footer: _templates2.default.footer,
                empty: DocSearch.getEmptyTemplate(),
              },
            },
          ]);
          var customHandleSelected = handleSelected;
          this.handleSelected = customHandleSelected || this.handleSelected;
          if (customHandleSelected) {
            (0, _zepto2.default)('.algolia-autocomplete').on(
              'click',
              '.ds-suggestions a',
              function (event) {
                event.preventDefault();
              },
            );
          }
          this.autocomplete.on(
            'autocomplete:selected',
            this.handleSelected.bind(null, this.autocomplete.autocomplete),
          );
          this.autocomplete.on('autocomplete:shown', this.handleShown.bind(null, this.input));
          if (enhancedSearchInput) {
            DocSearch.bindSearchBoxEvent();
          }
        }
        _createClass(
          DocSearch,
          [
            {
              key: 'getAutocompleteSource',
              value: function getAutocompleteSource(transformData, queryHook) {
                var _this = this;
                return function (query, callback) {
                  if (queryHook) {
                    query = queryHook(query) || query;
                  }
                  _this.client
                    .search([
                      { indexName: _this.indexName, query: query, params: _this.algoliaOptions },
                    ])
                    .then(function (data) {
                      if (_this.queryDataCallback && typeof _this.queryDataCallback == 'function') {
                        _this.queryDataCallback(data);
                      }
                      var hits = data.results[0].hits;
                      if (transformData) {
                        hits = transformData(hits) || hits;
                      }
                      callback(DocSearch.formatHits(hits));
                    });
                };
              },
            },
            {
              key: 'handleSelected',
              value: function handleSelected(input, event, suggestion, datasetNumber) {
                var context =
                  arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
                if (context.selectionMethod === 'click') {
                  return;
                }
                input.setVal('');
                window.location.assign(suggestion.url);
              },
            },
            {
              key: 'handleShown',
              value: function handleShown(input) {
                var middleOfInput = input.offset().left + input.width() / 2;
                var middleOfWindow = (0, _zepto2.default)(document).width() / 2;
                if (isNaN(middleOfWindow)) {
                  middleOfWindow = 900;
                }
                var alignClass =
                  middleOfInput - middleOfWindow >= 0
                    ? 'algolia-autocomplete-right'
                    : 'algolia-autocomplete-left';
                var otherAlignClass =
                  middleOfInput - middleOfWindow < 0
                    ? 'algolia-autocomplete-right'
                    : 'algolia-autocomplete-left';
                var autocompleteWrapper = (0, _zepto2.default)('.algolia-autocomplete');
                if (!autocompleteWrapper.hasClass(alignClass)) {
                  autocompleteWrapper.addClass(alignClass);
                }
                if (autocompleteWrapper.hasClass(otherAlignClass)) {
                  autocompleteWrapper.removeClass(otherAlignClass);
                }
              },
            },
          ],
          [
            {
              key: 'checkArguments',
              value: function checkArguments(args) {
                if (!args.apiKey || !args.indexName) {
                  throw new Error(usage);
                }
                if (typeof args.inputSelector !== 'string') {
                  throw new Error(
                    'Error: inputSelector:' +
                      args.inputSelector +
                      "  must be a string. Each selector must match only one element and separated by ','",
                  );
                }
                if (!DocSearch.getInputFromSelector(args.inputSelector)) {
                  throw new Error(
                    'Error: No input element in the page matches ' + args.inputSelector,
                  );
                }
              },
            },
            {
              key: 'injectSearchBox',
              value: function injectSearchBox(input) {
                input.before(_templates2.default.searchBox);
                var newInput = input.prev().prev().find('input');
                input.remove();
                return newInput;
              },
            },
            {
              key: 'bindSearchBoxEvent',
              value: function bindSearchBoxEvent() {
                (0, _zepto2.default)('.searchbox [type="reset"]').on('click', function () {
                  (0, _zepto2.default)('input#docsearch').focus();
                  (0, _zepto2.default)(this).addClass('hide');
                  _autocomplete2.default.autocomplete.setVal('');
                });
                (0, _zepto2.default)('input#docsearch').on('keyup', function () {
                  var searchbox = document.querySelector('input#docsearch');
                  var reset = document.querySelector('.searchbox [type="reset"]');
                  reset.className = 'searchbox__reset';
                  if (searchbox.value.length === 0) {
                    reset.className += ' hide';
                  }
                });
              },
            },
            {
              key: 'getInputFromSelector',
              value: function getInputFromSelector(selector) {
                var input = (0, _zepto2.default)(selector).filter('input');
                return input.length ? (0, _zepto2.default)(input[0]) : null;
              },
            },
            {
              key: 'formatHits',
              value: function formatHits(receivedHits) {
                var clonedHits = _utils2.default.deepClone(receivedHits);
                var hits = clonedHits.map(function (hit) {
                  if (hit._highlightResult) {
                    hit._highlightResult = _utils2.default.mergeKeyWithParent(
                      hit._highlightResult,
                      'hierarchy',
                    );
                  }
                  return _utils2.default.mergeKeyWithParent(hit, 'hierarchy');
                });
                var groupedHits = _utils2.default.groupBy(hits, 'lvl0');
                _zepto2.default.each(groupedHits, function (level, collection) {
                  var groupedHitsByLvl1 = _utils2.default.groupBy(collection, 'lvl1');
                  var flattenedHits = _utils2.default.flattenAndFlagFirst(
                    groupedHitsByLvl1,
                    'isSubCategoryHeader',
                  );
                  groupedHits[level] = flattenedHits;
                });
                groupedHits = _utils2.default.flattenAndFlagFirst(groupedHits, 'isCategoryHeader');
                return groupedHits.map(function (hit) {
                  var url = DocSearch.formatURL(hit);
                  var category = _utils2.default.getHighlightedValue(hit, 'lvl0');
                  var subcategory = _utils2.default.getHighlightedValue(hit, 'lvl1') || category;
                  var displayTitle = _utils2.default
                    .compact([
                      _utils2.default.getHighlightedValue(hit, 'lvl2') || subcategory,
                      _utils2.default.getHighlightedValue(hit, 'lvl3'),
                      _utils2.default.getHighlightedValue(hit, 'lvl4'),
                      _utils2.default.getHighlightedValue(hit, 'lvl5'),
                      _utils2.default.getHighlightedValue(hit, 'lvl6'),
                    ])
                    .join(
                      '<span class="aa-suggestion-title-separator" aria-hidden="true"> 鈥� </span>',
                    );
                  var text = _utils2.default.getSnippetedValue(hit, 'content');
                  var isTextOrSubcategoryNonEmpty =
                    (subcategory && subcategory !== '') || (displayTitle && displayTitle !== '');
                  var isLvl1EmptyOrDuplicate =
                    !subcategory || subcategory === '' || subcategory === category;
                  var isLvl2 = displayTitle && displayTitle !== '' && displayTitle !== subcategory;
                  var isLvl1 =
                    !isLvl2 && subcategory && subcategory !== '' && subcategory !== category;
                  var isLvl0 = !isLvl1 && !isLvl2;
                  return {
                    isLvl0: isLvl0,
                    isLvl1: isLvl1,
                    isLvl2: isLvl2,
                    isLvl1EmptyOrDuplicate: isLvl1EmptyOrDuplicate,
                    isCategoryHeader: hit.isCategoryHeader,
                    isSubCategoryHeader: hit.isSubCategoryHeader,
                    isTextOrSubcategoryNonEmpty: isTextOrSubcategoryNonEmpty,
                    category: category,
                    subcategory: subcategory,
                    title: displayTitle,
                    text: text,
                    url: url,
                  };
                });
              },
            },
            {
              key: 'formatURL',
              value: function formatURL(hit) {
                var url = hit.url,
                  anchor = hit.anchor;
                if (url) {
                  var containsAnchor = url.indexOf('#') !== -1;
                  if (containsAnchor) return url;
                  else if (anchor) return hit.url + '#' + hit.anchor;
                  return url;
                } else if (anchor) return '#' + hit.anchor;
                console.warn('no anchor nor url for : ', JSON.stringify(hit));
                return null;
              },
            },
            {
              key: 'getEmptyTemplate',
              value: function getEmptyTemplate() {
                return function (args) {
                  return _hogan2.default.compile(_templates2.default.empty).render(args);
                };
              },
            },
            {
              key: 'getSuggestionTemplate',
              value: function getSuggestionTemplate(isSimpleLayout) {
                var stringTemplate = isSimpleLayout
                  ? _templates2.default.suggestionSimple
                  : _templates2.default.suggestion;
                var template = _hogan2.default.compile(stringTemplate);
                return function (suggestion) {
                  return template.render(suggestion);
                };
              },
            },
          ],
        );
        return DocSearch;
      })();
      exports.default = DocSearch;
    },
    function (module, exports, __webpack_require__) {
      var Hogan = __webpack_require__(27);
      Hogan.Template = __webpack_require__(28).Template;
      Hogan.template = Hogan.Template;
      module.exports = Hogan;
    },
    function (module, exports, __webpack_require__) {
      (function (Hogan) {
        var rIsWhitespace = /\S/,
          rQuot = /\"/g,
          rNewline = /\n/g,
          rCr = /\r/g,
          rSlash = /\\/g,
          rLineSep = /\u2028/,
          rParagraphSep = /\u2029/;
        Hogan.tags = {
          '#': 1,
          '^': 2,
          '<': 3,
          $: 4,
          '/': 5,
          '!': 6,
          '>': 7,
          '=': 8,
          _v: 9,
          '{': 10,
          '&': 11,
          _t: 12,
        };
        Hogan.scan = function scan(text, delimiters) {
          var len = text.length,
            IN_TEXT = 0,
            IN_TAG_TYPE = 1,
            IN_TAG = 2,
            state = IN_TEXT,
            tagType = null,
            tag = null,
            buf = '',
            tokens = [],
            seenTag = false,
            i = 0,
            lineStart = 0,
            otag = '{{',
            ctag = '}}';
          function addBuf() {
            if (buf.length > 0) {
              tokens.push({ tag: '_t', text: new String(buf) });
              buf = '';
            }
          }
          function lineIsWhitespace() {
            var isAllWhitespace = true;
            for (var j = lineStart; j < tokens.length; j++) {
              isAllWhitespace =
                Hogan.tags[tokens[j].tag] < Hogan.tags['_v'] ||
                (tokens[j].tag == '_t' && tokens[j].text.match(rIsWhitespace) === null);
              if (!isAllWhitespace) {
                return false;
              }
            }
            return isAllWhitespace;
          }
          function filterLine(haveSeenTag, noNewLine) {
            addBuf();
            if (haveSeenTag && lineIsWhitespace()) {
              for (var j = lineStart, next; j < tokens.length; j++) {
                if (tokens[j].text) {
                  if ((next = tokens[j + 1]) && next.tag == '>') {
                    next.indent = tokens[j].text.toString();
                  }
                  tokens.splice(j, 1);
                }
              }
            } else if (!noNewLine) {
              tokens.push({ tag: '\n' });
            }
            seenTag = false;
            lineStart = tokens.length;
          }
          function changeDelimiters(text, index) {
            var close = '=' + ctag,
              closeIndex = text.indexOf(close, index),
              delimiters = trim(text.substring(text.indexOf('=', index) + 1, closeIndex)).split(
                ' ',
              );
            otag = delimiters[0];
            ctag = delimiters[delimiters.length - 1];
            return closeIndex + close.length - 1;
          }
          if (delimiters) {
            delimiters = delimiters.split(' ');
            otag = delimiters[0];
            ctag = delimiters[1];
          }
          for (i = 0; i < len; i++) {
            if (state == IN_TEXT) {
              if (tagChange(otag, text, i)) {
                --i;
                addBuf();
                state = IN_TAG_TYPE;
              } else {
                if (text.charAt(i) == '\n') {
                  filterLine(seenTag);
                } else {
                  buf += text.charAt(i);
                }
              }
            } else if (state == IN_TAG_TYPE) {
              i += otag.length - 1;
              tag = Hogan.tags[text.charAt(i + 1)];
              tagType = tag ? text.charAt(i + 1) : '_v';
              if (tagType == '=') {
                i = changeDelimiters(text, i);
                state = IN_TEXT;
              } else {
                if (tag) {
                  i++;
                }
                state = IN_TAG;
              }
              seenTag = i;
            } else {
              if (tagChange(ctag, text, i)) {
                tokens.push({
                  tag: tagType,
                  n: trim(buf),
                  otag: otag,
                  ctag: ctag,
                  i: tagType == '/' ? seenTag - otag.length : i + ctag.length,
                });
                buf = '';
                i += ctag.length - 1;
                state = IN_TEXT;
                if (tagType == '{') {
                  if (ctag == '}}') {
                    i++;
                  } else {
                    cleanTripleStache(tokens[tokens.length - 1]);
                  }
                }
              } else {
                buf += text.charAt(i);
              }
            }
          }
          filterLine(seenTag, true);
          return tokens;
        };
        function cleanTripleStache(token) {
          if (token.n.substr(token.n.length - 1) === '}') {
            token.n = token.n.substring(0, token.n.length - 1);
          }
        }
        function trim(s) {
          if (s.trim) {
            return s.trim();
          }
          return s.replace(/^\s*|\s*$/g, '');
        }
        function tagChange(tag, text, index) {
          if (text.charAt(index) != tag.charAt(0)) {
            return false;
          }
          for (var i = 1, l = tag.length; i < l; i++) {
            if (text.charAt(index + i) != tag.charAt(i)) {
              return false;
            }
          }
          return true;
        }
        var allowedInSuper = { _t: true, '\n': true, $: true, '/': true };
        function buildTree(tokens, kind, stack, customTags) {
          var instructions = [],
            opener = null,
            tail = null,
            token = null;
          tail = stack[stack.length - 1];
          while (tokens.length > 0) {
            token = tokens.shift();
            if (tail && tail.tag == '<' && !(token.tag in allowedInSuper)) {
              throw new Error('Illegal content in < super tag.');
            }
            if (Hogan.tags[token.tag] <= Hogan.tags['$'] || isOpener(token, customTags)) {
              stack.push(token);
              token.nodes = buildTree(tokens, token.tag, stack, customTags);
            } else if (token.tag == '/') {
              if (stack.length === 0) {
                throw new Error('Closing tag without opener: /' + token.n);
              }
              opener = stack.pop();
              if (token.n != opener.n && !isCloser(token.n, opener.n, customTags)) {
                throw new Error('Nesting error: ' + opener.n + ' vs. ' + token.n);
              }
              opener.end = token.i;
              return instructions;
            } else if (token.tag == '\n') {
              token.last = tokens.length == 0 || tokens[0].tag == '\n';
            }
            instructions.push(token);
          }
          if (stack.length > 0) {
            throw new Error('missing closing tag: ' + stack.pop().n);
          }
          return instructions;
        }
        function isOpener(token, tags) {
          for (var i = 0, l = tags.length; i < l; i++) {
            if (tags[i].o == token.n) {
              token.tag = '#';
              return true;
            }
          }
        }
        function isCloser(close, open, tags) {
          for (var i = 0, l = tags.length; i < l; i++) {
            if (tags[i].c == close && tags[i].o == open) {
              return true;
            }
          }
        }
        function stringifySubstitutions(obj) {
          var items = [];
          for (var key in obj) {
            items.push('"' + esc(key) + '": function(c,p,t,i) {' + obj[key] + '}');
          }
          return '{ ' + items.join(',') + ' }';
        }
        function stringifyPartials(codeObj) {
          var partials = [];
          for (var key in codeObj.partials) {
            partials.push(
              '"' +
                esc(key) +
                '":{name:"' +
                esc(codeObj.partials[key].name) +
                '", ' +
                stringifyPartials(codeObj.partials[key]) +
                '}',
            );
          }
          return (
            'partials: {' + partials.join(',') + '}, subs: ' + stringifySubstitutions(codeObj.subs)
          );
        }
        Hogan.stringify = function (codeObj, text, options) {
          return (
            '{code: function (c,p,i) { ' +
            Hogan.wrapMain(codeObj.code) +
            ' },' +
            stringifyPartials(codeObj) +
            '}'
          );
        };
        var serialNo = 0;
        Hogan.generate = function (tree, text, options) {
          serialNo = 0;
          var context = { code: '', subs: {}, partials: {} };
          Hogan.walk(tree, context);
          if (options.asString) {
            return this.stringify(context, text, options);
          }
          return this.makeTemplate(context, text, options);
        };
        Hogan.wrapMain = function (code) {
          return 'var t=this;t.b(i=i||"");' + code + 'return t.fl();';
        };
        Hogan.template = Hogan.Template;
        Hogan.makeTemplate = function (codeObj, text, options) {
          var template = this.makePartials(codeObj);
          template.code = new Function('c', 'p', 'i', this.wrapMain(codeObj.code));
          return new this.template(template, text, this, options);
        };
        Hogan.makePartials = function (codeObj) {
          var key,
            template = { subs: {}, partials: codeObj.partials, name: codeObj.name };
          for (key in template.partials) {
            template.partials[key] = this.makePartials(template.partials[key]);
          }
          for (key in codeObj.subs) {
            template.subs[key] = new Function('c', 'p', 't', 'i', codeObj.subs[key]);
          }
          return template;
        };
        function esc(s) {
          return s
            .replace(rSlash, '\\\\')
            .replace(rQuot, '\\"')
            .replace(rNewline, '\\n')
            .replace(rCr, '\\r')
            .replace(rLineSep, '\\u2028')
            .replace(rParagraphSep, '\\u2029');
        }
        function chooseMethod(s) {
          return ~s.indexOf('.') ? 'd' : 'f';
        }
        function createPartial(node, context) {
          var prefix = '<' + (context.prefix || '');
          var sym = prefix + node.n + serialNo++;
          context.partials[sym] = { name: node.n, partials: {} };
          context.code += 't.b(t.rp("' + esc(sym) + '",c,p,"' + (node.indent || '') + '"));';
          return sym;
        }
        Hogan.codegen = {
          '#': function (node, context) {
            context.code +=
              'if(t.s(t.' +
              chooseMethod(node.n) +
              '("' +
              esc(node.n) +
              '",c,p,1),' +
              'c,p,0,' +
              node.i +
              ',' +
              node.end +
              ',"' +
              node.otag +
              ' ' +
              node.ctag +
              '")){' +
              't.rs(c,p,' +
              'function(c,p,t){';
            Hogan.walk(node.nodes, context);
            context.code += '});c.pop();}';
          },
          '^': function (node, context) {
            context.code +=
              'if(!t.s(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,1),c,p,1,0,0,"")){';
            Hogan.walk(node.nodes, context);
            context.code += '};';
          },
          '>': createPartial,
          '<': function (node, context) {
            var ctx = { partials: {}, code: '', subs: {}, inPartial: true };
            Hogan.walk(node.nodes, ctx);
            var template = context.partials[createPartial(node, context)];
            template.subs = ctx.subs;
            template.partials = ctx.partials;
          },
          $: function (node, context) {
            var ctx = { subs: {}, code: '', partials: context.partials, prefix: node.n };
            Hogan.walk(node.nodes, ctx);
            context.subs[node.n] = ctx.code;
            if (!context.inPartial) {
              context.code += 't.sub("' + esc(node.n) + '",c,p,i);';
            }
          },
          '\n': function (node, context) {
            context.code += write('"\\n"' + (node.last ? '' : ' + i'));
          },
          _v: function (node, context) {
            context.code +=
              't.b(t.v(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));';
          },
          _t: function (node, context) {
            context.code += write('"' + esc(node.text) + '"');
          },
          '{': tripleStache,
          '&': tripleStache,
        };
        function tripleStache(node, context) {
          context.code += 't.b(t.t(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));';
        }
        function write(s) {
          return 't.b(' + s + ');';
        }
        Hogan.walk = function (nodelist, context) {
          var func;
          for (var i = 0, l = nodelist.length; i < l; i++) {
            func = Hogan.codegen[nodelist[i].tag];
            func && func(nodelist[i], context);
          }
          return context;
        };
        Hogan.parse = function (tokens, text, options) {
          options = options || {};
          return buildTree(tokens, '', [], options.sectionTags || []);
        };
        Hogan.cache = {};
        Hogan.cacheKey = function (text, options) {
          return [
            text,
            !!options.asString,
            !!options.disableLambda,
            options.delimiters,
            !!options.modelGet,
          ].join('||');
        };
        Hogan.compile = function (text, options) {
          options = options || {};
          var key = Hogan.cacheKey(text, options);
          var template = this.cache[key];
          if (template) {
            var partials = template.partials;
            for (var name in partials) {
              delete partials[name].instance;
            }
            return template;
          }
          template = this.generate(
            this.parse(this.scan(text, options.delimiters), text, options),
            text,
            options,
          );
          return (this.cache[key] = template);
        };
      })(true ? exports : Hogan);
    },
    function (module, exports, __webpack_require__) {
      var Hogan = {};
      (function (Hogan) {
        Hogan.Template = function (codeObj, text, compiler, options) {
          codeObj = codeObj || {};
          this.r = codeObj.code || this.r;
          this.c = compiler;
          this.options = options || {};
          this.text = text || '';
          this.partials = codeObj.partials || {};
          this.subs = codeObj.subs || {};
          this.buf = '';
        };
        Hogan.Template.prototype = {
          r: function (context, partials, indent) {
            return '';
          },
          v: hoganEscape,
          t: coerceToString,
          render: function render(context, partials, indent) {
            return this.ri([context], partials || {}, indent);
          },
          ri: function (context, partials, indent) {
            return this.r(context, partials, indent);
          },
          ep: function (symbol, partials) {
            var partial = this.partials[symbol];
            var template = partials[partial.name];
            if (partial.instance && partial.base == template) {
              return partial.instance;
            }
            if (typeof template == 'string') {
              if (!this.c) {
                throw new Error('No compiler available.');
              }
              template = this.c.compile(template, this.options);
            }
            if (!template) {
              return null;
            }
            this.partials[symbol].base = template;
            if (partial.subs) {
              if (!partials.stackText) partials.stackText = {};
              for (key in partial.subs) {
                if (!partials.stackText[key]) {
                  partials.stackText[key] =
                    this.activeSub !== undefined && partials.stackText[this.activeSub]
                      ? partials.stackText[this.activeSub]
                      : this.text;
                }
              }
              template = createSpecializedPartial(
                template,
                partial.subs,
                partial.partials,
                this.stackSubs,
                this.stackPartials,
                partials.stackText,
              );
            }
            this.partials[symbol].instance = template;
            return template;
          },
          rp: function (symbol, context, partials, indent) {
            var partial = this.ep(symbol, partials);
            if (!partial) {
              return '';
            }
            return partial.ri(context, partials, indent);
          },
          rs: function (context, partials, section) {
            var tail = context[context.length - 1];
            if (!isArray(tail)) {
              section(context, partials, this);
              return;
            }
            for (var i = 0; i < tail.length; i++) {
              context.push(tail[i]);
              section(context, partials, this);
              context.pop();
            }
          },
          s: function (val, ctx, partials, inverted, start, end, tags) {
            var pass;
            if (isArray(val) && val.length === 0) {
              return false;
            }
            if (typeof val == 'function') {
              val = this.ms(val, ctx, partials, inverted, start, end, tags);
            }
            pass = !!val;
            if (!inverted && pass && ctx) {
              ctx.push(typeof val == 'object' ? val : ctx[ctx.length - 1]);
            }
            return pass;
          },
          d: function (key, ctx, partials, returnFound) {
            var found,
              names = key.split('.'),
              val = this.f(names[0], ctx, partials, returnFound),
              doModelGet = this.options.modelGet,
              cx = null;
            if (key === '.' && isArray(ctx[ctx.length - 2])) {
              val = ctx[ctx.length - 1];
            } else {
              for (var i = 1; i < names.length; i++) {
                found = findInScope(names[i], val, doModelGet);
                if (found !== undefined) {
                  cx = val;
                  val = found;
                } else {
                  val = '';
                }
              }
            }
            if (returnFound && !val) {
              return false;
            }
            if (!returnFound && typeof val == 'function') {
              ctx.push(cx);
              val = this.mv(val, ctx, partials);
              ctx.pop();
            }
            return val;
          },
          f: function (key, ctx, partials, returnFound) {
            var val = false,
              v = null,
              found = false,
              doModelGet = this.options.modelGet;
            for (var i = ctx.length - 1; i >= 0; i--) {
              v = ctx[i];
              val = findInScope(key, v, doModelGet);
              if (val !== undefined) {
                found = true;
                break;
              }
            }
            if (!found) {
              return returnFound ? false : '';
            }
            if (!returnFound && typeof val == 'function') {
              val = this.mv(val, ctx, partials);
            }
            return val;
          },
          ls: function (func, cx, partials, text, tags) {
            var oldTags = this.options.delimiters;
            this.options.delimiters = tags;
            this.b(this.ct(coerceToString(func.call(cx, text)), cx, partials));
            this.options.delimiters = oldTags;
            return false;
          },
          ct: function (text, cx, partials) {
            if (this.options.disableLambda) {
              throw new Error('Lambda features disabled.');
            }
            return this.c.compile(text, this.options).render(cx, partials);
          },
          b: function (s) {
            this.buf += s;
          },
          fl: function () {
            var r = this.buf;
            this.buf = '';
            return r;
          },
          ms: function (func, ctx, partials, inverted, start, end, tags) {
            var textSource,
              cx = ctx[ctx.length - 1],
              result = func.call(cx);
            if (typeof result == 'function') {
              if (inverted) {
                return true;
              } else {
                textSource =
                  this.activeSub && this.subsText && this.subsText[this.activeSub]
                    ? this.subsText[this.activeSub]
                    : this.text;
                return this.ls(result, cx, partials, textSource.substring(start, end), tags);
              }
            }
            return result;
          },
          mv: function (func, ctx, partials) {
            var cx = ctx[ctx.length - 1];
            var result = func.call(cx);
            if (typeof result == 'function') {
              return this.ct(coerceToString(result.call(cx)), cx, partials);
            }
            return result;
          },
          sub: function (name, context, partials, indent) {
            var f = this.subs[name];
            if (f) {
              this.activeSub = name;
              f(context, partials, this, indent);
              this.activeSub = false;
            }
          },
        };
        function findInScope(key, scope, doModelGet) {
          var val;
          if (scope && typeof scope == 'object') {
            if (scope[key] !== undefined) {
              val = scope[key];
            } else if (doModelGet && scope.get && typeof scope.get == 'function') {
              val = scope.get(key);
            }
          }
          return val;
        }
        function createSpecializedPartial(
          instance,
          subs,
          partials,
          stackSubs,
          stackPartials,
          stackText,
        ) {
          function PartialTemplate() {}
          PartialTemplate.prototype = instance;
          function Substitutions() {}
          Substitutions.prototype = instance.subs;
          var key;
          var partial = new PartialTemplate();
          partial.subs = new Substitutions();
          partial.subsText = {};
          partial.buf = '';
          stackSubs = stackSubs || {};
          partial.stackSubs = stackSubs;
          partial.subsText = stackText;
          for (key in subs) {
            if (!stackSubs[key]) stackSubs[key] = subs[key];
          }
          for (key in stackSubs) {
            partial.subs[key] = stackSubs[key];
          }
          stackPartials = stackPartials || {};
          partial.stackPartials = stackPartials;
          for (key in partials) {
            if (!stackPartials[key]) stackPartials[key] = partials[key];
          }
          for (key in stackPartials) {
            partial.partials[key] = stackPartials[key];
          }
          return partial;
        }
        var rAmp = /&/g,
          rLt = /</g,
          rGt = />/g,
          rApos = /\'/g,
          rQuot = /\"/g,
          hChars = /[&<>\"\']/;
        function coerceToString(val) {
          return String(val === null || val === undefined ? '' : val);
        }
        function hoganEscape(str) {
          str = coerceToString(str);
          return hChars.test(str)
            ? str
                .replace(rAmp, '&amp;')
                .replace(rLt, '&lt;')
                .replace(rGt, '&gt;')
                .replace(rApos, '&#39;')
                .replace(rQuot, '&quot;')
            : str;
        }
        var isArray =
          Array.isArray ||
          function (a) {
            return Object.prototype.toString.call(a) === '[object Array]';
          };
      })(true ? exports : Hogan);
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var AlgoliaSearchCore = __webpack_require__(30);
      var createAlgoliasearch = __webpack_require__(41);
      module.exports = createAlgoliasearch(AlgoliaSearchCore, '(lite) ');
    },
    function (module, exports, __webpack_require__) {
      module.exports = AlgoliaSearchCore;
      var errors = __webpack_require__(5);
      var exitPromise = __webpack_require__(31);
      var IndexCore = __webpack_require__(32);
      var store = __webpack_require__(38);
      var MAX_API_KEY_LENGTH = 500;
      var RESET_APP_DATA_TIMER =
        (Object({ NODE_ENV: 'production' }).RESET_APP_DATA_TIMER &&
          parseInt(Object({ NODE_ENV: 'production' }).RESET_APP_DATA_TIMER, 10)) ||
        60 * 2 * 1e3;
      function AlgoliaSearchCore(applicationID, apiKey, opts) {
        var debug = __webpack_require__(8)('algoliasearch');
        var clone = __webpack_require__(3);
        var isArray = __webpack_require__(6);
        var map = __webpack_require__(7);
        var usage = 'Usage: algoliasearch(applicationID, apiKey, opts)';
        if (opts._allowEmptyCredentials !== true && !applicationID) {
          throw new errors.AlgoliaSearchError('Please provide an application ID. ' + usage);
        }
        if (opts._allowEmptyCredentials !== true && !apiKey) {
          throw new errors.AlgoliaSearchError('Please provide an API key. ' + usage);
        }
        this.applicationID = applicationID;
        this.apiKey = apiKey;
        this.hosts = { read: [], write: [] };
        opts = opts || {};
        this._timeouts = opts.timeouts || { connect: 1 * 1e3, read: 2 * 1e3, write: 30 * 1e3 };
        if (opts.timeout) {
          this._timeouts.connect = this._timeouts.read = this._timeouts.write = opts.timeout;
        }
        var protocol = opts.protocol || 'https:';
        if (!/:$/.test(protocol)) {
          protocol = protocol + ':';
        }
        if (protocol !== 'http:' && protocol !== 'https:') {
          throw new errors.AlgoliaSearchError(
            'protocol must be `http:` or `https:` (was `' + opts.protocol + '`)',
          );
        }
        this._checkAppIdData();
        if (!opts.hosts) {
          var defaultHosts = map(this._shuffleResult, function (hostNumber) {
            return applicationID + '-' + hostNumber + '.algolianet.com';
          });
          var mainSuffix = (opts.dsn === false ? '' : '-dsn') + '.algolia.net';
          this.hosts.read = [this.applicationID + mainSuffix].concat(defaultHosts);
          this.hosts.write = [this.applicationID + '.algolia.net'].concat(defaultHosts);
        } else if (isArray(opts.hosts)) {
          this.hosts.read = clone(opts.hosts);
          this.hosts.write = clone(opts.hosts);
        } else {
          this.hosts.read = clone(opts.hosts.read);
          this.hosts.write = clone(opts.hosts.write);
        }
        this.hosts.read = map(this.hosts.read, prepareHost(protocol));
        this.hosts.write = map(this.hosts.write, prepareHost(protocol));
        this.extraHeaders = {};
        this.cache = opts._cache || {};
        this._ua = opts._ua;
        this._useCache = opts._useCache === undefined || opts._cache ? true : opts._useCache;
        this._useRequestCache = this._useCache && opts._useRequestCache;
        this._useFallback = opts.useFallback === undefined ? true : opts.useFallback;
        this._setTimeout = opts._setTimeout;
        debug('init done, %j', this);
      }
      AlgoliaSearchCore.prototype.initIndex = function (indexName) {
        return new IndexCore(this, indexName);
      };
      AlgoliaSearchCore.prototype.setExtraHeader = function (name, value) {
        this.extraHeaders[name.toLowerCase()] = value;
      };
      AlgoliaSearchCore.prototype.getExtraHeader = function (name) {
        return this.extraHeaders[name.toLowerCase()];
      };
      AlgoliaSearchCore.prototype.unsetExtraHeader = function (name) {
        delete this.extraHeaders[name.toLowerCase()];
      };
      AlgoliaSearchCore.prototype.addAlgoliaAgent = function (algoliaAgent) {
        if (this._ua.indexOf(';' + algoliaAgent) === -1) {
          this._ua += ';' + algoliaAgent;
        }
      };
      AlgoliaSearchCore.prototype._jsonRequest = function (initialOpts) {
        this._checkAppIdData();
        var requestDebug = __webpack_require__(8)('algoliasearch:' + initialOpts.url);
        var body;
        var cacheID;
        var additionalUA = initialOpts.additionalUA || '';
        var cache = initialOpts.cache;
        var client = this;
        var tries = 0;
        var usingFallback = false;
        var hasFallback = client._useFallback && client._request.fallback && initialOpts.fallback;
        var headers;
        if (
          this.apiKey.length > MAX_API_KEY_LENGTH &&
          initialOpts.body !== undefined &&
          (initialOpts.body.params !== undefined || initialOpts.body.requests !== undefined)
        ) {
          initialOpts.body.apiKey = this.apiKey;
          headers = this._computeRequestHeaders({
            additionalUA: additionalUA,
            withApiKey: false,
            headers: initialOpts.headers,
          });
        } else {
          headers = this._computeRequestHeaders({
            additionalUA: additionalUA,
            headers: initialOpts.headers,
          });
        }
        if (initialOpts.body !== undefined) {
          body = safeJSONStringify(initialOpts.body);
        }
        requestDebug('request start');
        var debugData = [];
        function doRequest(requester, reqOpts) {
          client._checkAppIdData();
          var startTime = new Date();
          if (client._useCache && !client._useRequestCache) {
            cacheID = initialOpts.url;
          }
          if (client._useCache && !client._useRequestCache && body) {
            cacheID += '_body_' + reqOpts.body;
          }
          if (isCacheValidWithCurrentID(!client._useRequestCache, cache, cacheID)) {
            requestDebug('serving response from cache');
            var responseText = cache[cacheID];
            return client._promise.resolve({
              body: JSON.parse(responseText),
              responseText: responseText,
            });
          }
          if (tries >= client.hosts[initialOpts.hostType].length) {
            if (!hasFallback || usingFallback) {
              requestDebug('could not get any response');
              return client._promise.reject(
                new errors.AlgoliaSearchError(
                  'Cannot connect to the AlgoliaSearch API.' +
                    ' Send an email to support@algolia.com to report and resolve the issue.' +
                    ' Application id was: ' +
                    client.applicationID,
                  { debugData: debugData },
                ),
              );
            }
            requestDebug('switching to fallback');
            tries = 0;
            reqOpts.method = initialOpts.fallback.method;
            reqOpts.url = initialOpts.fallback.url;
            reqOpts.jsonBody = initialOpts.fallback.body;
            if (reqOpts.jsonBody) {
              reqOpts.body = safeJSONStringify(reqOpts.jsonBody);
            }
            headers = client._computeRequestHeaders({
              additionalUA: additionalUA,
              headers: initialOpts.headers,
            });
            reqOpts.timeouts = client._getTimeoutsForRequest(initialOpts.hostType);
            client._setHostIndexByType(0, initialOpts.hostType);
            usingFallback = true;
            return doRequest(client._request.fallback, reqOpts);
          }
          var currentHost = client._getHostByType(initialOpts.hostType);
          var url = currentHost + reqOpts.url;
          var options = {
            body: reqOpts.body,
            jsonBody: reqOpts.jsonBody,
            method: reqOpts.method,
            headers: headers,
            timeouts: reqOpts.timeouts,
            debug: requestDebug,
            forceAuthHeaders: reqOpts.forceAuthHeaders,
          };
          requestDebug(
            'method: %s, url: %s, headers: %j, timeouts: %d',
            options.method,
            url,
            options.headers,
            options.timeouts,
          );
          if (requester === client._request.fallback) {
            requestDebug('using fallback');
          }
          return requester.call(client, url, options).then(success, tryFallback);
          function success(httpResponse) {
            var status =
              (httpResponse &&
                httpResponse.body &&
                httpResponse.body.message &&
                httpResponse.body.status) ||
              httpResponse.statusCode ||
              (httpResponse && httpResponse.body && 200);
            requestDebug(
              'received response: statusCode: %s, computed statusCode: %d, headers: %j',
              httpResponse.statusCode,
              status,
              httpResponse.headers,
            );
            var httpResponseOk = Math.floor(status / 100) === 2;
            var endTime = new Date();
            debugData.push({
              currentHost: currentHost,
              headers: removeCredentials(headers),
              content: body || null,
              contentLength: body !== undefined ? body.length : null,
              method: reqOpts.method,
              timeouts: reqOpts.timeouts,
              url: reqOpts.url,
              startTime: startTime,
              endTime: endTime,
              duration: endTime - startTime,
              statusCode: status,
            });
            if (httpResponseOk) {
              if (client._useCache && !client._useRequestCache && cache) {
                cache[cacheID] = httpResponse.responseText;
              }
              return { responseText: httpResponse.responseText, body: httpResponse.body };
            }
            var shouldRetry = Math.floor(status / 100) !== 4;
            if (shouldRetry) {
              tries += 1;
              return retryRequest();
            }
            requestDebug('unrecoverable error');
            var unrecoverableError = new errors.AlgoliaSearchError(
              httpResponse.body && httpResponse.body.message,
              { debugData: debugData, statusCode: status },
            );
            return client._promise.reject(unrecoverableError);
          }
          function tryFallback(err) {
            requestDebug('error: %s, stack: %s', err.message, err.stack);
            var endTime = new Date();
            debugData.push({
              currentHost: currentHost,
              headers: removeCredentials(headers),
              content: body || null,
              contentLength: body !== undefined ? body.length : null,
              method: reqOpts.method,
              timeouts: reqOpts.timeouts,
              url: reqOpts.url,
              startTime: startTime,
              endTime: endTime,
              duration: endTime - startTime,
            });
            if (!(err instanceof errors.AlgoliaSearchError)) {
              err = new errors.Unknown(err && err.message, err);
            }
            tries += 1;
            if (
              err instanceof errors.Unknown ||
              err instanceof errors.UnparsableJSON ||
              (tries >= client.hosts[initialOpts.hostType].length &&
                (usingFallback || !hasFallback))
            ) {
              err.debugData = debugData;
              return client._promise.reject(err);
            }
            if (err instanceof errors.RequestTimeout) {
              return retryRequestWithHigherTimeout();
            }
            return retryRequest();
          }
          function retryRequest() {
            requestDebug('retrying request');
            client._incrementHostIndex(initialOpts.hostType);
            return doRequest(requester, reqOpts);
          }
          function retryRequestWithHigherTimeout() {
            requestDebug('retrying request with higher timeout');
            client._incrementHostIndex(initialOpts.hostType);
            client._incrementTimeoutMultipler();
            reqOpts.timeouts = client._getTimeoutsForRequest(initialOpts.hostType);
            return doRequest(requester, reqOpts);
          }
        }
        function isCacheValidWithCurrentID(useRequestCache, currentCache, currentCacheID) {
          return (
            client._useCache &&
            useRequestCache &&
            currentCache &&
            currentCache[currentCacheID] !== undefined
          );
        }
        function interopCallbackReturn(request, callback) {
          if (isCacheValidWithCurrentID(client._useRequestCache, cache, cacheID)) {
            request.catch(function () {
              delete cache[cacheID];
            });
          }
          if (typeof initialOpts.callback === 'function') {
            request.then(
              function okCb(content) {
                exitPromise(function () {
                  initialOpts.callback(null, callback(content));
                }, client._setTimeout || setTimeout);
              },
              function nookCb(err) {
                exitPromise(function () {
                  initialOpts.callback(err);
                }, client._setTimeout || setTimeout);
              },
            );
          } else {
            return request.then(callback);
          }
        }
        if (client._useCache && client._useRequestCache) {
          cacheID = initialOpts.url;
        }
        if (client._useCache && client._useRequestCache && body) {
          cacheID += '_body_' + body;
        }
        if (isCacheValidWithCurrentID(client._useRequestCache, cache, cacheID)) {
          requestDebug('serving request from cache');
          var maybePromiseForCache = cache[cacheID];
          var promiseForCache =
            typeof maybePromiseForCache.then !== 'function'
              ? client._promise.resolve({ responseText: maybePromiseForCache })
              : maybePromiseForCache;
          return interopCallbackReturn(promiseForCache, function (content) {
            return JSON.parse(content.responseText);
          });
        }
        var request = doRequest(client._request, {
          url: initialOpts.url,
          method: initialOpts.method,
          body: body,
          jsonBody: initialOpts.body,
          timeouts: client._getTimeoutsForRequest(initialOpts.hostType),
          forceAuthHeaders: initialOpts.forceAuthHeaders,
        });
        if (client._useCache && client._useRequestCache && cache) {
          cache[cacheID] = request;
        }
        return interopCallbackReturn(request, function (content) {
          return content.body;
        });
      };
      AlgoliaSearchCore.prototype._getSearchParams = function (args, params) {
        if (args === undefined || args === null) {
          return params;
        }
        for (var key in args) {
          if (key !== null && args[key] !== undefined && args.hasOwnProperty(key)) {
            params += params === '' ? '' : '&';
            params +=
              key +
              '=' +
              encodeURIComponent(
                Object.prototype.toString.call(args[key]) === '[object Array]'
                  ? safeJSONStringify(args[key])
                  : args[key],
              );
          }
        }
        return params;
      };
      AlgoliaSearchCore.prototype._computeRequestHeaders = function (options) {
        var forEach = __webpack_require__(2);
        var ua = options.additionalUA ? this._ua + ';' + options.additionalUA : this._ua;
        var requestHeaders = {
          'x-algolia-agent': ua,
          'x-algolia-application-id': this.applicationID,
        };
        if (options.withApiKey !== false) {
          requestHeaders['x-algolia-api-key'] = this.apiKey;
        }
        if (this.userToken) {
          requestHeaders['x-algolia-usertoken'] = this.userToken;
        }
        if (this.securityTags) {
          requestHeaders['x-algolia-tagfilters'] = this.securityTags;
        }
        forEach(this.extraHeaders, function addToRequestHeaders(value, key) {
          requestHeaders[key] = value;
        });
        if (options.headers) {
          forEach(options.headers, function addToRequestHeaders(value, key) {
            requestHeaders[key] = value;
          });
        }
        return requestHeaders;
      };
      AlgoliaSearchCore.prototype.search = function (queries, opts, callback) {
        var isArray = __webpack_require__(6);
        var map = __webpack_require__(7);
        var usage = 'Usage: client.search(arrayOfQueries[, callback])';
        if (!isArray(queries)) {
          throw new Error(usage);
        }
        if (typeof opts === 'function') {
          callback = opts;
          opts = {};
        } else if (opts === undefined) {
          opts = {};
        }
        var client = this;
        var postObj = {
          requests: map(queries, function prepareRequest(query) {
            var params = '';
            if (query.query !== undefined) {
              params += 'query=' + encodeURIComponent(query.query);
            }
            return {
              indexName: query.indexName,
              params: client._getSearchParams(query.params, params),
            };
          }),
        };
        var JSONPParams = map(postObj.requests, function prepareJSONPParams(request, requestId) {
          return (
            requestId +
            '=' +
            encodeURIComponent(
              '/1/indexes/' + encodeURIComponent(request.indexName) + '?' + request.params,
            )
          );
        }).join('&');
        var url = '/1/indexes/*/queries';
        if (opts.strategy !== undefined) {
          postObj.strategy = opts.strategy;
        }
        return this._jsonRequest({
          cache: this.cache,
          method: 'POST',
          url: url,
          body: postObj,
          hostType: 'read',
          fallback: { method: 'GET', url: '/1/indexes/*', body: { params: JSONPParams } },
          callback: callback,
        });
      };
      AlgoliaSearchCore.prototype.searchForFacetValues = function (queries) {
        var isArray = __webpack_require__(6);
        var map = __webpack_require__(7);
        var usage =
          'Usage: client.searchForFacetValues([{indexName, params: {facetName, facetQuery, ...params}}, ...queries])';
        if (!isArray(queries)) {
          throw new Error(usage);
        }
        var client = this;
        return client._promise.all(
          map(queries, function performQuery(query) {
            if (
              !query ||
              query.indexName === undefined ||
              query.params.facetName === undefined ||
              query.params.facetQuery === undefined
            ) {
              throw new Error(usage);
            }
            var clone = __webpack_require__(3);
            var omit = __webpack_require__(14);
            var indexName = query.indexName;
            var params = query.params;
            var facetName = params.facetName;
            var filteredParams = omit(clone(params), function (keyName) {
              return keyName === 'facetName';
            });
            var searchParameters = client._getSearchParams(filteredParams, '');
            return client._jsonRequest({
              cache: client.cache,
              method: 'POST',
              url:
                '/1/indexes/' +
                encodeURIComponent(indexName) +
                '/facets/' +
                encodeURIComponent(facetName) +
                '/query',
              hostType: 'read',
              body: { params: searchParameters },
            });
          }),
        );
      };
      AlgoliaSearchCore.prototype.setSecurityTags = function (tags) {
        if (Object.prototype.toString.call(tags) === '[object Array]') {
          var strTags = [];
          for (var i = 0; i < tags.length; ++i) {
            if (Object.prototype.toString.call(tags[i]) === '[object Array]') {
              var oredTags = [];
              for (var j = 0; j < tags[i].length; ++j) {
                oredTags.push(tags[i][j]);
              }
              strTags.push('(' + oredTags.join(',') + ')');
            } else {
              strTags.push(tags[i]);
            }
          }
          tags = strTags.join(',');
        }
        this.securityTags = tags;
      };
      AlgoliaSearchCore.prototype.setUserToken = function (userToken) {
        this.userToken = userToken;
      };
      AlgoliaSearchCore.prototype.clearCache = function () {
        this.cache = {};
      };
      AlgoliaSearchCore.prototype.setRequestTimeout = function (milliseconds) {
        if (milliseconds) {
          this._timeouts.connect = this._timeouts.read = this._timeouts.write = milliseconds;
        }
      };
      AlgoliaSearchCore.prototype.setTimeouts = function (timeouts) {
        this._timeouts = timeouts;
      };
      AlgoliaSearchCore.prototype.getTimeouts = function () {
        return this._timeouts;
      };
      AlgoliaSearchCore.prototype._getAppIdData = function () {
        var data = store.get(this.applicationID);
        if (data !== null) this._cacheAppIdData(data);
        return data;
      };
      AlgoliaSearchCore.prototype._setAppIdData = function (data) {
        data.lastChange = new Date().getTime();
        this._cacheAppIdData(data);
        return store.set(this.applicationID, data);
      };
      AlgoliaSearchCore.prototype._checkAppIdData = function () {
        var data = this._getAppIdData();
        var now = new Date().getTime();
        if (data === null || now - data.lastChange > RESET_APP_DATA_TIMER) {
          return this._resetInitialAppIdData(data);
        }
        return data;
      };
      AlgoliaSearchCore.prototype._resetInitialAppIdData = function (data) {
        var newData = data || {};
        newData.hostIndexes = { read: 0, write: 0 };
        newData.timeoutMultiplier = 1;
        newData.shuffleResult = newData.shuffleResult || shuffle([1, 2, 3]);
        return this._setAppIdData(newData);
      };
      AlgoliaSearchCore.prototype._cacheAppIdData = function (data) {
        this._hostIndexes = data.hostIndexes;
        this._timeoutMultiplier = data.timeoutMultiplier;
        this._shuffleResult = data.shuffleResult;
      };
      AlgoliaSearchCore.prototype._partialAppIdDataUpdate = function (newData) {
        var foreach = __webpack_require__(2);
        var currentData = this._getAppIdData();
        foreach(newData, function (value, key) {
          currentData[key] = value;
        });
        return this._setAppIdData(currentData);
      };
      AlgoliaSearchCore.prototype._getHostByType = function (hostType) {
        return this.hosts[hostType][this._getHostIndexByType(hostType)];
      };
      AlgoliaSearchCore.prototype._getTimeoutMultiplier = function () {
        return this._timeoutMultiplier;
      };
      AlgoliaSearchCore.prototype._getHostIndexByType = function (hostType) {
        return this._hostIndexes[hostType];
      };
      AlgoliaSearchCore.prototype._setHostIndexByType = function (hostIndex, hostType) {
        var clone = __webpack_require__(3);
        var newHostIndexes = clone(this._hostIndexes);
        newHostIndexes[hostType] = hostIndex;
        this._partialAppIdDataUpdate({ hostIndexes: newHostIndexes });
        return hostIndex;
      };
      AlgoliaSearchCore.prototype._incrementHostIndex = function (hostType) {
        return this._setHostIndexByType(
          (this._getHostIndexByType(hostType) + 1) % this.hosts[hostType].length,
          hostType,
        );
      };
      AlgoliaSearchCore.prototype._incrementTimeoutMultipler = function () {
        var timeoutMultiplier = Math.max(this._timeoutMultiplier + 1, 4);
        return this._partialAppIdDataUpdate({ timeoutMultiplier: timeoutMultiplier });
      };
      AlgoliaSearchCore.prototype._getTimeoutsForRequest = function (hostType) {
        return {
          connect: this._timeouts.connect * this._timeoutMultiplier,
          complete: this._timeouts[hostType] * this._timeoutMultiplier,
        };
      };
      function prepareHost(protocol) {
        return function prepare(host) {
          return protocol + '//' + host.toLowerCase();
        };
      }
      function safeJSONStringify(obj) {
        if (Array.prototype.toJSON === undefined) {
          return JSON.stringify(obj);
        }
        var toJSON = Array.prototype.toJSON;
        delete Array.prototype.toJSON;
        var out = JSON.stringify(obj);
        Array.prototype.toJSON = toJSON;
        return out;
      }
      function shuffle(array) {
        var currentIndex = array.length;
        var temporaryValue;
        var randomIndex;
        while (currentIndex !== 0) {
          randomIndex = Math.floor(Math.random() * currentIndex);
          currentIndex -= 1;
          temporaryValue = array[currentIndex];
          array[currentIndex] = array[randomIndex];
          array[randomIndex] = temporaryValue;
        }
        return array;
      }
      function removeCredentials(headers) {
        var newHeaders = {};
        for (var headerName in headers) {
          if (Object.prototype.hasOwnProperty.call(headers, headerName)) {
            var value;
            if (headerName === 'x-algolia-api-key' || headerName === 'x-algolia-application-id') {
              value = '**hidden for security purposes**';
            } else {
              value = headers[headerName];
            }
            newHeaders[headerName] = value;
          }
        }
        return newHeaders;
      }
    },
    function (module, exports) {
      module.exports = function exitPromise(fn, _setTimeout) {
        _setTimeout(fn, 0);
      };
    },
    function (module, exports, __webpack_require__) {
      var buildSearchMethod = __webpack_require__(13);
      var deprecate = __webpack_require__(33);
      var deprecatedMessage = __webpack_require__(34);
      module.exports = IndexCore;
      function IndexCore(algoliasearch, indexName) {
        this.indexName = indexName;
        this.as = algoliasearch;
        this.typeAheadArgs = null;
        this.typeAheadValueOption = null;
        this.cache = {};
      }
      IndexCore.prototype.clearCache = function () {
        this.cache = {};
      };
      IndexCore.prototype.search = buildSearchMethod('query');
      IndexCore.prototype.similarSearch = buildSearchMethod('similarQuery');
      IndexCore.prototype.browse = function (query, queryParameters, callback) {
        var merge = __webpack_require__(35);
        var indexObj = this;
        var page;
        var hitsPerPage;
        if (
          arguments.length === 0 ||
          (arguments.length === 1 && typeof arguments[0] === 'function')
        ) {
          page = 0;
          callback = arguments[0];
          query = undefined;
        } else if (typeof arguments[0] === 'number') {
          page = arguments[0];
          if (typeof arguments[1] === 'number') {
            hitsPerPage = arguments[1];
          } else if (typeof arguments[1] === 'function') {
            callback = arguments[1];
            hitsPerPage = undefined;
          }
          query = undefined;
          queryParameters = undefined;
        } else if (typeof arguments[0] === 'object') {
          if (typeof arguments[1] === 'function') {
            callback = arguments[1];
          }
          queryParameters = arguments[0];
          query = undefined;
        } else if (typeof arguments[0] === 'string' && typeof arguments[1] === 'function') {
          callback = arguments[1];
          queryParameters = undefined;
        }
        queryParameters = merge({}, queryParameters || {}, {
          page: page,
          hitsPerPage: hitsPerPage,
          query: query,
        });
        var params = this.as._getSearchParams(queryParameters, '');
        return this.as._jsonRequest({
          method: 'POST',
          url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/browse',
          body: { params: params },
          hostType: 'read',
          callback: callback,
        });
      };
      IndexCore.prototype.browseFrom = function (cursor, callback) {
        return this.as._jsonRequest({
          method: 'POST',
          url: '/1/indexes/' + encodeURIComponent(this.indexName) + '/browse',
          body: { cursor: cursor },
          hostType: 'read',
          callback: callback,
        });
      };
      IndexCore.prototype.searchForFacetValues = function (params, callback) {
        var clone = __webpack_require__(3);
        var omit = __webpack_require__(14);
        var usage =
          'Usage: index.searchForFacetValues({facetName, facetQuery, ...params}[, callback])';
        if (params.facetName === undefined || params.facetQuery === undefined) {
          throw new Error(usage);
        }
        var facetName = params.facetName;
        var filteredParams = omit(clone(params), function (keyName) {
          return keyName === 'facetName';
        });
        var searchParameters = this.as._getSearchParams(filteredParams, '');
        return this.as._jsonRequest({
          method: 'POST',
          url:
            '/1/indexes/' +
            encodeURIComponent(this.indexName) +
            '/facets/' +
            encodeURIComponent(facetName) +
            '/query',
          hostType: 'read',
          body: { params: searchParameters },
          callback: callback,
        });
      };
      IndexCore.prototype.searchFacet = deprecate(function (params, callback) {
        return this.searchForFacetValues(params, callback);
      }, deprecatedMessage(
        'index.searchFacet(params[, callback])',
        'index.searchForFacetValues(params[, callback])',
      ));
      IndexCore.prototype._search = function (params, url, callback, additionalUA) {
        return this.as._jsonRequest({
          cache: this.cache,
          method: 'POST',
          url: url || '/1/indexes/' + encodeURIComponent(this.indexName) + '/query',
          body: { params: params },
          hostType: 'read',
          fallback: {
            method: 'GET',
            url: '/1/indexes/' + encodeURIComponent(this.indexName),
            body: { params: params },
          },
          callback: callback,
          additionalUA: additionalUA,
        });
      };
      IndexCore.prototype.getObject = function (objectID, attrs, callback) {
        var indexObj = this;
        if (arguments.length === 1 || typeof attrs === 'function') {
          callback = attrs;
          attrs = undefined;
        }
        var params = '';
        if (attrs !== undefined) {
          params = '?attributes=';
          for (var i = 0; i < attrs.length; ++i) {
            if (i !== 0) {
              params += ',';
            }
            params += attrs[i];
          }
        }
        return this.as._jsonRequest({
          method: 'GET',
          url:
            '/1/indexes/' +
            encodeURIComponent(indexObj.indexName) +
            '/' +
            encodeURIComponent(objectID) +
            params,
          hostType: 'read',
          callback: callback,
        });
      };
      IndexCore.prototype.getObjects = function (objectIDs, attributesToRetrieve, callback) {
        var isArray = __webpack_require__(6);
        var map = __webpack_require__(7);
        var usage = 'Usage: index.getObjects(arrayOfObjectIDs[, callback])';
        if (!isArray(objectIDs)) {
          throw new Error(usage);
        }
        var indexObj = this;
        if (arguments.length === 1 || typeof attributesToRetrieve === 'function') {
          callback = attributesToRetrieve;
          attributesToRetrieve = undefined;
        }
        var body = {
          requests: map(objectIDs, function prepareRequest(objectID) {
            var request = { indexName: indexObj.indexName, objectID: objectID };
            if (attributesToRetrieve) {
              request.attributesToRetrieve = attributesToRetrieve.join(',');
            }
            return request;
          }),
        };
        return this.as._jsonRequest({
          method: 'POST',
          url: '/1/indexes/*/objects',
          hostType: 'read',
          body: body,
          callback: callback,
        });
      };
      IndexCore.prototype.as = null;
      IndexCore.prototype.indexName = null;
      IndexCore.prototype.typeAheadArgs = null;
      IndexCore.prototype.typeAheadValueOption = null;
    },
    function (module, exports) {
      module.exports = function deprecate(fn, message) {
        var warned = false;
        function deprecated() {
          if (!warned) {
            console.warn(message);
            warned = true;
          }
          return fn.apply(this, arguments);
        }
        return deprecated;
      };
    },
    function (module, exports) {
      module.exports = function deprecatedMessage(previousUsage, newUsage) {
        var githubAnchorLink = previousUsage.toLowerCase().replace(/[\.\(\)]/g, '');
        return (
          'algoliasearch: `' +
          previousUsage +
          '` was replaced by `' +
          newUsage +
          '`. Please see https://github.com/algolia/algoliasearch-client-javascript/wiki/Deprecated#' +
          githubAnchorLink
        );
      };
    },
    function (module, exports, __webpack_require__) {
      var foreach = __webpack_require__(2);
      module.exports = function merge(destination) {
        var sources = Array.prototype.slice.call(arguments);
        foreach(sources, function (source) {
          for (var keyName in source) {
            if (source.hasOwnProperty(keyName)) {
              if (typeof destination[keyName] === 'object' && typeof source[keyName] === 'object') {
                destination[keyName] = merge({}, destination[keyName], source[keyName]);
              } else if (source[keyName] !== undefined) {
                destination[keyName] = source[keyName];
              }
            }
          }
        });
        return destination;
      };
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var has = Object.prototype.hasOwnProperty;
      var toStr = Object.prototype.toString;
      var slice = Array.prototype.slice;
      var isArgs = __webpack_require__(37);
      var isEnumerable = Object.prototype.propertyIsEnumerable;
      var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
      var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
      var dontEnums = [
        'toString',
        'toLocaleString',
        'valueOf',
        'hasOwnProperty',
        'isPrototypeOf',
        'propertyIsEnumerable',
        'constructor',
      ];
      var equalsConstructorPrototype = function (o) {
        var ctor = o.constructor;
        return ctor && ctor.prototype === o;
      };
      var excludedKeys = {
        $applicationCache: true,
        $console: true,
        $external: true,
        $frame: true,
        $frameElement: true,
        $frames: true,
        $innerHeight: true,
        $innerWidth: true,
        $outerHeight: true,
        $outerWidth: true,
        $pageXOffset: true,
        $pageYOffset: true,
        $parent: true,
        $scrollLeft: true,
        $scrollTop: true,
        $scrollX: true,
        $scrollY: true,
        $self: true,
        $webkitIndexedDB: true,
        $webkitStorageInfo: true,
        $window: true,
      };
      var hasAutomationEqualityBug = (function () {
        if (typeof window === 'undefined') {
          return false;
        }
        for (var k in window) {
          try {
            if (
              !excludedKeys['$' + k] &&
              has.call(window, k) &&
              window[k] !== null &&
              typeof window[k] === 'object'
            ) {
              try {
                equalsConstructorPrototype(window[k]);
              } catch (e) {
                return true;
              }
            }
          } catch (e) {
            return true;
          }
        }
        return false;
      })();
      var equalsConstructorPrototypeIfNotBuggy = function (o) {
        if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
          return equalsConstructorPrototype(o);
        }
        try {
          return equalsConstructorPrototype(o);
        } catch (e) {
          return false;
        }
      };
      var keysShim = function keys(object) {
        var isObject = object !== null && typeof object === 'object';
        var isFunction = toStr.call(object) === '[object Function]';
        var isArguments = isArgs(object);
        var isString = isObject && toStr.call(object) === '[object String]';
        var theKeys = [];
        if (!isObject && !isFunction && !isArguments) {
          throw new TypeError('Object.keys called on a non-object');
        }
        var skipProto = hasProtoEnumBug && isFunction;
        if (isString && object.length > 0 && !has.call(object, 0)) {
          for (var i = 0; i < object.length; ++i) {
            theKeys.push(String(i));
          }
        }
        if (isArguments && object.length > 0) {
          for (var j = 0; j < object.length; ++j) {
            theKeys.push(String(j));
          }
        } else {
          for (var name in object) {
            if (!(skipProto && name === 'prototype') && has.call(object, name)) {
              theKeys.push(String(name));
            }
          }
        }
        if (hasDontEnumBug) {
          var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
          for (var k = 0; k < dontEnums.length; ++k) {
            if (
              !(skipConstructor && dontEnums[k] === 'constructor') &&
              has.call(object, dontEnums[k])
            ) {
              theKeys.push(dontEnums[k]);
            }
          }
        }
        return theKeys;
      };
      keysShim.shim = function shimObjectKeys() {
        if (Object.keys) {
          var keysWorksWithArguments = (function () {
            return (Object.keys(arguments) || '').length === 2;
          })(1, 2);
          if (!keysWorksWithArguments) {
            var originalKeys = Object.keys;
            Object.keys = function keys(object) {
              if (isArgs(object)) {
                return originalKeys(slice.call(object));
              } else {
                return originalKeys(object);
              }
            };
          }
        } else {
          Object.keys = keysShim;
        }
        return Object.keys || keysShim;
      };
      module.exports = keysShim;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var toStr = Object.prototype.toString;
      module.exports = function isArguments(value) {
        var str = toStr.call(value);
        var isArgs = str === '[object Arguments]';
        if (!isArgs) {
          isArgs =
            str !== '[object Array]' &&
            value !== null &&
            typeof value === 'object' &&
            typeof value.length === 'number' &&
            value.length >= 0 &&
            toStr.call(value.callee) === '[object Function]';
        }
        return isArgs;
      };
    },
    function (module, exports, __webpack_require__) {
      (function (global) {
        var debug = __webpack_require__(8)('algoliasearch:src/hostIndexState.js');
        var localStorageNamespace = 'algoliasearch-client-js';
        var store;
        var moduleStore = {
          state: {},
          set: function (key, data) {
            this.state[key] = data;
            return this.state[key];
          },
          get: function (key) {
            return this.state[key] || null;
          },
        };
        var localStorageStore = {
          set: function (key, data) {
            moduleStore.set(key, data);
            try {
              var namespace = JSON.parse(global.localStorage[localStorageNamespace]);
              namespace[key] = data;
              global.localStorage[localStorageNamespace] = JSON.stringify(namespace);
              return namespace[key];
            } catch (e) {
              return localStorageFailure(key, e);
            }
          },
          get: function (key) {
            try {
              return JSON.parse(global.localStorage[localStorageNamespace])[key] || null;
            } catch (e) {
              return localStorageFailure(key, e);
            }
          },
        };
        function localStorageFailure(key, e) {
          debug('localStorage failed with', e);
          cleanup();
          store = moduleStore;
          return store.get(key);
        }
        store = supportsLocalStorage() ? localStorageStore : moduleStore;
        module.exports = {
          get: getOrSet,
          set: getOrSet,
          supportsLocalStorage: supportsLocalStorage,
        };
        function getOrSet(key, data) {
          if (arguments.length === 1) {
            return store.get(key);
          }
          return store.set(key, data);
        }
        function supportsLocalStorage() {
          try {
            if ('localStorage' in global && global.localStorage !== null) {
              if (!global.localStorage[localStorageNamespace]) {
                global.localStorage.setItem(localStorageNamespace, JSON.stringify({}));
              }
              return true;
            }
            return false;
          } catch (_) {
            return false;
          }
        }
        function cleanup() {
          try {
            global.localStorage.removeItem(localStorageNamespace);
          } catch (_) {}
        }
      }).call(exports, __webpack_require__(4));
    },
    function (module, exports, __webpack_require__) {
      exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
      exports.coerce = coerce;
      exports.disable = disable;
      exports.enable = enable;
      exports.enabled = enabled;
      exports.humanize = __webpack_require__(40);
      exports.names = [];
      exports.skips = [];
      exports.formatters = {};
      var prevTime;
      function selectColor(namespace) {
        var hash = 0,
          i;
        for (i in namespace) {
          hash = (hash << 5) - hash + namespace.charCodeAt(i);
          hash |= 0;
        }
        return exports.colors[Math.abs(hash) % exports.colors.length];
      }
      function createDebug(namespace) {
        function debug() {
          if (!debug.enabled) return;
          var self = debug;
          var curr = +new Date();
          var ms = curr - (prevTime || curr);
          self.diff = ms;
          self.prev = prevTime;
          self.curr = curr;
          prevTime = curr;
          var args = new Array(arguments.length);
          for (var i = 0; i < args.length; i++) {
            args[i] = arguments[i];
          }
          args[0] = exports.coerce(args[0]);
          if ('string' !== typeof args[0]) {
            args.unshift('%O');
          }
          var index = 0;
          args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
            if (match === '%%') return match;
            index++;
            var formatter = exports.formatters[format];
            if ('function' === typeof formatter) {
              var val = args[index];
              match = formatter.call(self, val);
              args.splice(index, 1);
              index--;
            }
            return match;
          });
          exports.formatArgs.call(self, args);
          var logFn = debug.log || exports.log || console.log.bind(console);
          logFn.apply(self, args);
        }
        debug.namespace = namespace;
        debug.enabled = exports.enabled(namespace);
        debug.useColors = exports.useColors();
        debug.color = selectColor(namespace);
        if ('function' === typeof exports.init) {
          exports.init(debug);
        }
        return debug;
      }
      function enable(namespaces) {
        exports.save(namespaces);
        exports.names = [];
        exports.skips = [];
        var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
        var len = split.length;
        for (var i = 0; i < len; i++) {
          if (!split[i]) continue;
          namespaces = split[i].replace(/\*/g, '.*?');
          if (namespaces[0] === '-') {
            exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
          } else {
            exports.names.push(new RegExp('^' + namespaces + '$'));
          }
        }
      }
      function disable() {
        exports.enable('');
      }
      function enabled(name) {
        var i, len;
        for (i = 0, len = exports.skips.length; i < len; i++) {
          if (exports.skips[i].test(name)) {
            return false;
          }
        }
        for (i = 0, len = exports.names.length; i < len; i++) {
          if (exports.names[i].test(name)) {
            return true;
          }
        }
        return false;
      }
      function coerce(val) {
        if (val instanceof Error) return val.stack || val.message;
        return val;
      }
    },
    function (module, exports) {
      var s = 1e3;
      var m = s * 60;
      var h = m * 60;
      var d = h * 24;
      var y = d * 365.25;
      module.exports = function (val, options) {
        options = options || {};
        var type = typeof val;
        if (type === 'string' && val.length > 0) {
          return parse(val);
        } else if (type === 'number' && isNaN(val) === false) {
          return options.long ? fmtLong(val) : fmtShort(val);
        }
        throw new Error(
          'val is not a non-empty string or a valid number. val=' + JSON.stringify(val),
        );
      };
      function parse(str) {
        str = String(str);
        if (str.length > 100) {
          return;
        }
        var match =
          /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
            str,
          );
        if (!match) {
          return;
        }
        var n = parseFloat(match[1]);
        var type = (match[2] || 'ms').toLowerCase();
        switch (type) {
          case 'years':
          case 'year':
          case 'yrs':
          case 'yr':
          case 'y':
            return n * y;
          case 'days':
          case 'day':
          case 'd':
            return n * d;
          case 'hours':
          case 'hour':
          case 'hrs':
          case 'hr':
          case 'h':
            return n * h;
          case 'minutes':
          case 'minute':
          case 'mins':
          case 'min':
          case 'm':
            return n * m;
          case 'seconds':
          case 'second':
          case 'secs':
          case 'sec':
          case 's':
            return n * s;
          case 'milliseconds':
          case 'millisecond':
          case 'msecs':
          case 'msec':
          case 'ms':
            return n;
          default:
            return undefined;
        }
      }
      function fmtShort(ms) {
        if (ms >= d) {
          return Math.round(ms / d) + 'd';
        }
        if (ms >= h) {
          return Math.round(ms / h) + 'h';
        }
        if (ms >= m) {
          return Math.round(ms / m) + 'm';
        }
        if (ms >= s) {
          return Math.round(ms / s) + 's';
        }
        return ms + 'ms';
      }
      function fmtLong(ms) {
        return (
          plural(ms, d, 'day') ||
          plural(ms, h, 'hour') ||
          plural(ms, m, 'minute') ||
          plural(ms, s, 'second') ||
          ms + ' ms'
        );
      }
      function plural(ms, n, name) {
        if (ms < n) {
          return;
        }
        if (ms < n * 1.5) {
          return Math.floor(ms / n) + ' ' + name;
        }
        return Math.ceil(ms / n) + ' ' + name + 's';
      }
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var global = __webpack_require__(42);
      var Promise = global.Promise || __webpack_require__(43).Promise;
      module.exports = function createAlgoliasearch(AlgoliaSearch, uaSuffix) {
        var inherits = __webpack_require__(12);
        var errors = __webpack_require__(5);
        var inlineHeaders = __webpack_require__(44);
        var jsonpRequest = __webpack_require__(46);
        var places = __webpack_require__(47);
        uaSuffix = uaSuffix || '';
        function algoliasearch(applicationID, apiKey, opts) {
          var cloneDeep = __webpack_require__(3);
          opts = cloneDeep(opts || {});
          opts._ua = opts._ua || algoliasearch.ua;
          return new AlgoliaSearchBrowser(applicationID, apiKey, opts);
        }
        algoliasearch.version = __webpack_require__(48);
        algoliasearch.ua = 'Algolia for vanilla JavaScript ' + uaSuffix + algoliasearch.version;
        algoliasearch.initPlaces = places(algoliasearch);
        global.__algolia = { debug: __webpack_require__(8), algoliasearch: algoliasearch };
        var support = {
          hasXMLHttpRequest: 'XMLHttpRequest' in global,
          hasXDomainRequest: 'XDomainRequest' in global,
        };
        if (support.hasXMLHttpRequest) {
          support.cors = 'withCredentials' in new XMLHttpRequest();
        }
        function AlgoliaSearchBrowser() {
          AlgoliaSearch.apply(this, arguments);
        }
        inherits(AlgoliaSearchBrowser, AlgoliaSearch);
        AlgoliaSearchBrowser.prototype._request = function request(url, opts) {
          return new Promise(function wrapRequest(resolve, reject) {
            if (!support.cors && !support.hasXDomainRequest) {
              reject(new errors.Network('CORS not supported'));
              return;
            }
            url = inlineHeaders(url, opts.headers);
            var body = opts.body;
            var req = support.cors ? new XMLHttpRequest() : new XDomainRequest();
            var reqTimeout;
            var timedOut;
            var connected = false;
            reqTimeout = setTimeout(onTimeout, opts.timeouts.connect);
            req.onprogress = onProgress;
            if ('onreadystatechange' in req) req.onreadystatechange = onReadyStateChange;
            req.onload = onLoad;
            req.onerror = onError;
            if (req instanceof XMLHttpRequest) {
              req.open(opts.method, url, true);
              if (opts.forceAuthHeaders) {
                req.setRequestHeader(
                  'x-algolia-application-id',
                  opts.headers['x-algolia-application-id'],
                );
                req.setRequestHeader('x-algolia-api-key', opts.headers['x-algolia-api-key']);
              }
            } else {
              req.open(opts.method, url);
            }
            if (support.cors) {
              if (body) {
                if (opts.method === 'POST') {
                  req.setRequestHeader('content-type', 'application/x-www-form-urlencoded');
                } else {
                  req.setRequestHeader('content-type', 'application/json');
                }
              }
              req.setRequestHeader('accept', 'application/json');
            }
            if (body) {
              req.send(body);
            } else {
              req.send();
            }
            function onLoad() {
              if (timedOut) {
                return;
              }
              clearTimeout(reqTimeout);
              var out;
              try {
                out = {
                  body: JSON.parse(req.responseText),
                  responseText: req.responseText,
                  statusCode: req.status,
                  headers: (req.getAllResponseHeaders && req.getAllResponseHeaders()) || {},
                };
              } catch (e) {
                out = new errors.UnparsableJSON({ more: req.responseText });
              }
              if (out instanceof errors.UnparsableJSON) {
                reject(out);
              } else {
                resolve(out);
              }
            }
            function onError(event) {
              if (timedOut) {
                return;
              }
              clearTimeout(reqTimeout);
              reject(new errors.Network({ more: event }));
            }
            function onTimeout() {
              timedOut = true;
              req.abort();
              reject(new errors.RequestTimeout());
            }
            function onConnect() {
              connected = true;
              clearTimeout(reqTimeout);
              reqTimeout = setTimeout(onTimeout, opts.timeouts.complete);
            }
            function onProgress() {
              if (!connected) onConnect();
            }
            function onReadyStateChange() {
              if (!connected && req.readyState > 1) onConnect();
            }
          });
        };
        AlgoliaSearchBrowser.prototype._request.fallback = function requestFallback(url, opts) {
          url = inlineHeaders(url, opts.headers);
          return new Promise(function wrapJsonpRequest(resolve, reject) {
            jsonpRequest(url, opts, function jsonpRequestDone(err, content) {
              if (err) {
                reject(err);
                return;
              }
              resolve(content);
            });
          });
        };
        AlgoliaSearchBrowser.prototype._promise = {
          reject: function rejectPromise(val) {
            return Promise.reject(val);
          },
          resolve: function resolvePromise(val) {
            return Promise.resolve(val);
          },
          delay: function delayPromise(ms) {
            return new Promise(function resolveOnTimeout(resolve) {
              setTimeout(resolve, ms);
            });
          },
          all: function all(promises) {
            return Promise.all(promises);
          },
        };
        return algoliasearch;
      };
    },
    function (module, exports, __webpack_require__) {
      (function (global) {
        var win;
        if (typeof window !== 'undefined') {
          win = window;
        } else if (typeof global !== 'undefined') {
          win = global;
        } else if (typeof self !== 'undefined') {
          win = self;
        } else {
          win = {};
        }
        module.exports = win;
      }).call(exports, __webpack_require__(4));
    },
    function (module, exports, __webpack_require__) {
      (function (process, global) {
        (function (global, factory) {
          true
            ? (module.exports = factory())
            : typeof define === 'function' && define.amd
            ? define(factory)
            : (global.ES6Promise = factory());
        })(this, function () {
          'use strict';
          function objectOrFunction(x) {
            var type = typeof x;
            return x !== null && (type === 'object' || type === 'function');
          }
          function isFunction(x) {
            return typeof x === 'function';
          }
          var _isArray = void 0;
          if (Array.isArray) {
            _isArray = Array.isArray;
          } else {
            _isArray = function (x) {
              return Object.prototype.toString.call(x) === '[object Array]';
            };
          }
          var isArray = _isArray;
          var len = 0;
          var vertxNext = void 0;
          var customSchedulerFn = void 0;
          var asap = function asap(callback, arg) {
            queue[len] = callback;
            queue[len + 1] = arg;
            len += 2;
            if (len === 2) {
              if (customSchedulerFn) {
                customSchedulerFn(flush);
              } else {
                scheduleFlush();
              }
            }
          };
          function setScheduler(scheduleFn) {
            customSchedulerFn = scheduleFn;
          }
          function setAsap(asapFn) {
            asap = asapFn;
          }
          var browserWindow = typeof window !== 'undefined' ? window : undefined;
          var browserGlobal = browserWindow || {};
          var BrowserMutationObserver =
            browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
          var isNode =
            typeof self === 'undefined' &&
            typeof process !== 'undefined' &&
            {}.toString.call(process) === '[object process]';
          var isWorker =
            typeof Uint8ClampedArray !== 'undefined' &&
            typeof importScripts !== 'undefined' &&
            typeof MessageChannel !== 'undefined';
          function useNextTick() {
            return function () {
              return process.nextTick(flush);
            };
          }
          function useVertxTimer() {
            if (typeof vertxNext !== 'undefined') {
              return function () {
                vertxNext(flush);
              };
            }
            return useSetTimeout();
          }
          function useMutationObserver() {
            var iterations = 0;
            var observer = new BrowserMutationObserver(flush);
            var node = document.createTextNode('');
            observer.observe(node, { characterData: true });
            return function () {
              node.data = iterations = ++iterations % 2;
            };
          }
          function useMessageChannel() {
            var channel = new MessageChannel();
            channel.port1.onmessage = flush;
            return function () {
              return channel.port2.postMessage(0);
            };
          }
          function useSetTimeout() {
            var globalSetTimeout = setTimeout;
            return function () {
              return globalSetTimeout(flush, 1);
            };
          }
          var queue = new Array(1e3);
          function flush() {
            for (var i = 0; i < len; i += 2) {
              var callback = queue[i];
              var arg = queue[i + 1];
              callback(arg);
              queue[i] = undefined;
              queue[i + 1] = undefined;
            }
            len = 0;
          }
          function attemptVertx() {
            try {
              var vertx = Function('return this')().require('vertx');
              vertxNext = vertx.runOnLoop || vertx.runOnContext;
              return useVertxTimer();
            } catch (e) {
              return useSetTimeout();
            }
          }
          var scheduleFlush = void 0;
          if (isNode) {
            scheduleFlush = useNextTick();
          } else if (BrowserMutationObserver) {
            scheduleFlush = useMutationObserver();
          } else if (isWorker) {
            scheduleFlush = useMessageChannel();
          } else if (browserWindow === undefined && 'function' === 'function') {
            scheduleFlush = attemptVertx();
          } else {
            scheduleFlush = useSetTimeout();
          }
          function then(onFulfillment, onRejection) {
            var parent = this;
            var child = new this.constructor(noop);
            if (child[PROMISE_ID] === undefined) {
              makePromise(child);
            }
            var _state = parent._state;
            if (_state) {
              var callback = arguments[_state - 1];
              asap(function () {
                return invokeCallback(_state, child, callback, parent._result);
              });
            } else {
              subscribe(parent, child, onFulfillment, onRejection);
            }
            return child;
          }
          function resolve$1(object) {
            var Constructor = this;
            if (object && typeof object === 'object' && object.constructor === Constructor) {
              return object;
            }
            var promise = new Constructor(noop);
            resolve(promise, object);
            return promise;
          }
          var PROMISE_ID = Math.random().toString(36).substring(2);
          function noop() {}
          var PENDING = void 0;
          var FULFILLED = 1;
          var REJECTED = 2;
          var TRY_CATCH_ERROR = { error: null };
          function selfFulfillment() {
            return new TypeError('You cannot resolve a promise with itself');
          }
          function cannotReturnOwn() {
            return new TypeError('A promises callback cannot return that same promise.');
          }
          function getThen(promise) {
            try {
              return promise.then;
            } catch (error) {
              TRY_CATCH_ERROR.error = error;
              return TRY_CATCH_ERROR;
            }
          }
          function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
            try {
              then$$1.call(value, fulfillmentHandler, rejectionHandler);
            } catch (e) {
              return e;
            }
          }
          function handleForeignThenable(promise, thenable, then$$1) {
            asap(function (promise) {
              var sealed = false;
              var error = tryThen(
                then$$1,
                thenable,
                function (value) {
                  if (sealed) {
                    return;
                  }
                  sealed = true;
                  if (thenable !== value) {
                    resolve(promise, value);
                  } else {
                    fulfill(promise, value);
                  }
                },
                function (reason) {
                  if (sealed) {
                    return;
                  }
                  sealed = true;
                  reject(promise, reason);
                },
                'Settle: ' + (promise._label || ' unknown promise'),
              );
              if (!sealed && error) {
                sealed = true;
                reject(promise, error);
              }
            }, promise);
          }
          function handleOwnThenable(promise, thenable) {
            if (thenable._state === FULFILLED) {
              fulfill(promise, thenable._result);
            } else if (thenable._state === REJECTED) {
              reject(promise, thenable._result);
            } else {
              subscribe(
                thenable,
                undefined,
                function (value) {
                  return resolve(promise, value);
                },
                function (reason) {
                  return reject(promise, reason);
                },
              );
            }
          }
          function handleMaybeThenable(promise, maybeThenable, then$$1) {
            if (
              maybeThenable.constructor === promise.constructor &&
              then$$1 === then &&
              maybeThenable.constructor.resolve === resolve$1
            ) {
              handleOwnThenable(promise, maybeThenable);
            } else {
              if (then$$1 === TRY_CATCH_ERROR) {
                reject(promise, TRY_CATCH_ERROR.error);
                TRY_CATCH_ERROR.error = null;
              } else if (then$$1 === undefined) {
                fulfill(promise, maybeThenable);
              } else if (isFunction(then$$1)) {
                handleForeignThenable(promise, maybeThenable, then$$1);
              } else {
                fulfill(promise, maybeThenable);
              }
            }
          }
          function resolve(promise, value) {
            if (promise === value) {
              reject(promise, selfFulfillment());
            } else if (objectOrFunction(value)) {
              handleMaybeThenable(promise, value, getThen(value));
            } else {
              fulfill(promise, value);
            }
          }
          function publishRejection(promise) {
            if (promise._onerror) {
              promise._onerror(promise._result);
            }
            publish(promise);
          }
          function fulfill(promise, value) {
            if (promise._state !== PENDING) {
              return;
            }
            promise._result = value;
            promise._state = FULFILLED;
            if (promise._subscribers.length !== 0) {
              asap(publish, promise);
            }
          }
          function reject(promise, reason) {
            if (promise._state !== PENDING) {
              return;
            }
            promise._state = REJECTED;
            promise._result = reason;
            asap(publishRejection, promise);
          }
          function subscribe(parent, child, onFulfillment, onRejection) {
            var _subscribers = parent._subscribers;
            var length = _subscribers.length;
            parent._onerror = null;
            _subscribers[length] = child;
            _subscribers[length + FULFILLED] = onFulfillment;
            _subscribers[length + REJECTED] = onRejection;
            if (length === 0 && parent._state) {
              asap(publish, parent);
            }
          }
          function publish(promise) {
            var subscribers = promise._subscribers;
            var settled = promise._state;
            if (subscribers.length === 0) {
              return;
            }
            var child = void 0,
              callback = void 0,
              detail = promise._result;
            for (var i = 0; i < subscribers.length; i += 3) {
              child = subscribers[i];
              callback = subscribers[i + settled];
              if (child) {
                invokeCallback(settled, child, callback, detail);
              } else {
                callback(detail);
              }
            }
            promise._subscribers.length = 0;
          }
          function tryCatch(callback, detail) {
            try {
              return callback(detail);
            } catch (e) {
              TRY_CATCH_ERROR.error = e;
              return TRY_CATCH_ERROR;
            }
          }
          function invokeCallback(settled, promise, callback, detail) {
            var hasCallback = isFunction(callback),
              value = void 0,
              error = void 0,
              succeeded = void 0,
              failed = void 0;
            if (hasCallback) {
              value = tryCatch(callback, detail);
              if (value === TRY_CATCH_ERROR) {
                failed = true;
                error = value.error;
                value.error = null;
              } else {
                succeeded = true;
              }
              if (promise === value) {
                reject(promise, cannotReturnOwn());
                return;
              }
            } else {
              value = detail;
              succeeded = true;
            }
            if (promise._state !== PENDING) {
            } else if (hasCallback && succeeded) {
              resolve(promise, value);
            } else if (failed) {
              reject(promise, error);
            } else if (settled === FULFILLED) {
              fulfill(promise, value);
            } else if (settled === REJECTED) {
              reject(promise, value);
            }
          }
          function initializePromise(promise, resolver) {
            try {
              resolver(
                function resolvePromise(value) {
                  resolve(promise, value);
                },
                function rejectPromise(reason) {
                  reject(promise, reason);
                },
              );
            } catch (e) {
              reject(promise, e);
            }
          }
          var id = 0;
          function nextId() {
            return id++;
          }
          function makePromise(promise) {
            promise[PROMISE_ID] = id++;
            promise._state = undefined;
            promise._result = undefined;
            promise._subscribers = [];
          }
          function validationError() {
            return new Error('Array Methods must be provided an Array');
          }
          var Enumerator = (function () {
            function Enumerator(Constructor, input) {
              this._instanceConstructor = Constructor;
              this.promise = new Constructor(noop);
              if (!this.promise[PROMISE_ID]) {
                makePromise(this.promise);
              }
              if (isArray(input)) {
                this.length = input.length;
                this._remaining = input.length;
                this._result = new Array(this.length);
                if (this.length === 0) {
                  fulfill(this.promise, this._result);
                } else {
                  this.length = this.length || 0;
                  this._enumerate(input);
                  if (this._remaining === 0) {
                    fulfill(this.promise, this._result);
                  }
                }
              } else {
                reject(this.promise, validationError());
              }
            }
            Enumerator.prototype._enumerate = function _enumerate(input) {
              for (var i = 0; this._state === PENDING && i < input.length; i++) {
                this._eachEntry(input[i], i);
              }
            };
            Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
              var c = this._instanceConstructor;
              var resolve$$1 = c.resolve;
              if (resolve$$1 === resolve$1) {
                var _then = getThen(entry);
                if (_then === then && entry._state !== PENDING) {
                  this._settledAt(entry._state, i, entry._result);
                } else if (typeof _then !== 'function') {
                  this._remaining--;
                  this._result[i] = entry;
                } else if (c === Promise$1) {
                  var promise = new c(noop);
                  handleMaybeThenable(promise, entry, _then);
                  this._willSettleAt(promise, i);
                } else {
                  this._willSettleAt(
                    new c(function (resolve$$1) {
                      return resolve$$1(entry);
                    }),
                    i,
                  );
                }
              } else {
                this._willSettleAt(resolve$$1(entry), i);
              }
            };
            Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
              var promise = this.promise;
              if (promise._state === PENDING) {
                this._remaining--;
                if (state === REJECTED) {
                  reject(promise, value);
                } else {
                  this._result[i] = value;
                }
              }
              if (this._remaining === 0) {
                fulfill(promise, this._result);
              }
            };
            Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
              var enumerator = this;
              subscribe(
                promise,
                undefined,
                function (value) {
                  return enumerator._settledAt(FULFILLED, i, value);
                },
                function (reason) {
                  return enumerator._settledAt(REJECTED, i, reason);
                },
              );
            };
            return Enumerator;
          })();
          function all(entries) {
            return new Enumerator(this, entries).promise;
          }
          function race(entries) {
            var Constructor = this;
            if (!isArray(entries)) {
              return new Constructor(function (_, reject) {
                return 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);
                }
              });
            }
          }
          function reject$1(reason) {
            var Constructor = this;
            var promise = new Constructor(noop);
            reject(promise, reason);
            return promise;
          }
          function needsResolver() {
            throw new TypeError(
              'You must pass a resolver function as the first argument to the promise constructor',
            );
          }
          function needsNew() {
            throw new TypeError(
              "Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.",
            );
          }
          var Promise$1 = (function () {
            function Promise(resolver) {
              this[PROMISE_ID] = nextId();
              this._result = this._state = undefined;
              this._subscribers = [];
              if (noop !== resolver) {
                typeof resolver !== 'function' && needsResolver();
                this instanceof Promise ? initializePromise(this, resolver) : needsNew();
              }
            }
            Promise.prototype.catch = function _catch(onRejection) {
              return this.then(null, onRejection);
            };
            Promise.prototype.finally = function _finally(callback) {
              var promise = this;
              var constructor = promise.constructor;
              return promise.then(
                function (value) {
                  return constructor.resolve(callback()).then(function () {
                    return value;
                  });
                },
                function (reason) {
                  return constructor.resolve(callback()).then(function () {
                    throw reason;
                  });
                },
              );
            };
            return Promise;
          })();
          Promise$1.prototype.then = then;
          Promise$1.all = all;
          Promise$1.race = race;
          Promise$1.resolve = resolve$1;
          Promise$1.reject = reject$1;
          Promise$1._setScheduler = setScheduler;
          Promise$1._setAsap = setAsap;
          Promise$1._asap = asap;
          function polyfill() {
            var local = void 0;
            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) {
              var promiseToString = null;
              try {
                promiseToString = Object.prototype.toString.call(P.resolve());
              } catch (e) {}
              if (promiseToString === '[object Promise]' && !P.cast) {
                return;
              }
            }
            local.Promise = Promise$1;
          }
          Promise$1.polyfill = polyfill;
          Promise$1.Promise = Promise$1;
          return Promise$1;
        });
      }).call(exports, __webpack_require__(9), __webpack_require__(4));
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      module.exports = inlineHeaders;
      var encode = __webpack_require__(45);
      function inlineHeaders(url, headers) {
        if (/\?/.test(url)) {
          url += '&';
        } else {
          url += '?';
        }
        return url + encode(headers);
      }
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var stringifyPrimitive = function (v) {
        switch (typeof v) {
          case 'string':
            return v;
          case 'boolean':
            return v ? 'true' : 'false';
          case 'number':
            return isFinite(v) ? v : '';
          default:
            return '';
        }
      };
      module.exports = function (obj, sep, eq, name) {
        sep = sep || '&';
        eq = eq || '=';
        if (obj === null) {
          obj = undefined;
        }
        if (typeof obj === 'object') {
          return map(objectKeys(obj), function (k) {
            var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
            if (isArray(obj[k])) {
              return map(obj[k], function (v) {
                return ks + encodeURIComponent(stringifyPrimitive(v));
              }).join(sep);
            } else {
              return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
            }
          }).join(sep);
        }
        if (!name) return '';
        return (
          encodeURIComponent(stringifyPrimitive(name)) +
          eq +
          encodeURIComponent(stringifyPrimitive(obj))
        );
      };
      var isArray =
        Array.isArray ||
        function (xs) {
          return Object.prototype.toString.call(xs) === '[object Array]';
        };
      function map(xs, f) {
        if (xs.map) return xs.map(f);
        var res = [];
        for (var i = 0; i < xs.length; i++) {
          res.push(f(xs[i], i));
        }
        return res;
      }
      var objectKeys =
        Object.keys ||
        function (obj) {
          var res = [];
          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
          }
          return res;
        };
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      module.exports = jsonpRequest;
      var errors = __webpack_require__(5);
      var JSONPCounter = 0;
      function jsonpRequest(url, opts, cb) {
        if (opts.method !== 'GET') {
          cb(new Error('Method ' + opts.method + ' ' + url + ' is not supported by JSONP.'));
          return;
        }
        opts.debug('JSONP: start');
        var cbCalled = false;
        var timedOut = false;
        JSONPCounter += 1;
        var head = document.getElementsByTagName('head')[0];
        var script = document.createElement('script');
        var cbName = 'algoliaJSONP_' + JSONPCounter;
        var done = false;
        window[cbName] = function (data) {
          removeGlobals();
          if (timedOut) {
            opts.debug('JSONP: Late answer, ignoring');
            return;
          }
          cbCalled = true;
          clean();
          cb(null, { body: data, responseText: JSON.stringify(data) });
        };
        url += '&callback=' + cbName;
        if (opts.jsonBody && opts.jsonBody.params) {
          url += '&' + opts.jsonBody.params;
        }
        var ontimeout = setTimeout(timeout, opts.timeouts.complete);
        script.onreadystatechange = readystatechange;
        script.onload = success;
        script.onerror = error;
        script.async = true;
        script.defer = true;
        script.src = url;
        head.appendChild(script);
        function success() {
          opts.debug('JSONP: success');
          if (done || timedOut) {
            return;
          }
          done = true;
          if (!cbCalled) {
            opts.debug('JSONP: Fail. Script loaded but did not call the callback');
            clean();
            cb(new errors.JSONPScriptFail());
          }
        }
        function readystatechange() {
          if (this.readyState === 'loaded' || this.readyState === 'complete') {
            success();
          }
        }
        function clean() {
          clearTimeout(ontimeout);
          script.onload = null;
          script.onreadystatechange = null;
          script.onerror = null;
          head.removeChild(script);
        }
        function removeGlobals() {
          try {
            delete window[cbName];
            delete window[cbName + '_loaded'];
          } catch (e) {
            window[cbName] = window[cbName + '_loaded'] = undefined;
          }
        }
        function timeout() {
          opts.debug('JSONP: Script timeout');
          timedOut = true;
          clean();
          cb(new errors.RequestTimeout());
        }
        function error() {
          opts.debug('JSONP: Script error');
          if (done || timedOut) {
            return;
          }
          clean();
          cb(new errors.JSONPScriptError());
        }
      }
    },
    function (module, exports, __webpack_require__) {
      module.exports = createPlacesClient;
      var buildSearchMethod = __webpack_require__(13);
      function createPlacesClient(algoliasearch) {
        return function places(appID, apiKey, opts) {
          var cloneDeep = __webpack_require__(3);
          opts = (opts && cloneDeep(opts)) || {};
          opts.hosts = opts.hosts || [
            'places-dsn.algolia.net',
            'places-1.algolianet.com',
            'places-2.algolianet.com',
            'places-3.algolianet.com',
          ];
          if (arguments.length === 0 || typeof appID === 'object' || appID === undefined) {
            appID = '';
            apiKey = '';
            opts._allowEmptyCredentials = true;
          }
          var client = algoliasearch(appID, apiKey, opts);
          var index = client.initIndex('places');
          index.search = buildSearchMethod('query', '/1/places/query');
          index.getObject = function (objectID, callback) {
            return this.as._jsonRequest({
              method: 'GET',
              url: '/1/places/' + encodeURIComponent(objectID),
              hostType: 'read',
              callback: callback,
            });
          };
          return index;
        };
      }
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      module.exports = '3.30.0';
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      module.exports = __webpack_require__(50);
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var zepto = __webpack_require__(15);
      var DOM = __webpack_require__(1);
      DOM.element = zepto;
      var _ = __webpack_require__(0);
      _.isArray = zepto.isArray;
      _.isFunction = zepto.isFunction;
      _.isObject = zepto.isPlainObject;
      _.bind = zepto.proxy;
      _.each = function (collection, cb) {
        zepto.each(collection, reverseArgs);
        function reverseArgs(index, value) {
          return cb(value, index);
        }
      };
      _.map = zepto.map;
      _.mixin = zepto.extend;
      _.Event = zepto.Event;
      var typeaheadKey = 'aaAutocomplete';
      var Typeahead = __webpack_require__(51);
      var EventBus = __webpack_require__(16);
      function autocomplete(selector, options, datasets, typeaheadObject) {
        datasets = _.isArray(datasets) ? datasets : [].slice.call(arguments, 2);
        var inputs = zepto(selector).each(function (i, input) {
          var $input = zepto(input);
          var eventBus = new EventBus({ el: $input });
          var typeahead =
            typeaheadObject ||
            new Typeahead({
              input: $input,
              eventBus: eventBus,
              dropdownMenuContainer: options.dropdownMenuContainer,
              hint: options.hint === undefined ? true : !!options.hint,
              minLength: options.minLength,
              autoselect: options.autoselect,
              autoselectOnBlur: options.autoselectOnBlur,
              tabAutocomplete: options.tabAutocomplete,
              openOnFocus: options.openOnFocus,
              templates: options.templates,
              debug: options.debug,
              clearOnSelected: options.clearOnSelected,
              cssClasses: options.cssClasses,
              datasets: datasets,
              keyboardShortcuts: options.keyboardShortcuts,
              appendTo: options.appendTo,
              autoWidth: options.autoWidth,
              ariaLabel: options.ariaLabel || input.getAttribute('aria-label'),
            });
          $input.data(typeaheadKey, typeahead);
        });
        inputs.autocomplete = {};
        _.each(['open', 'close', 'getVal', 'setVal', 'destroy', 'getWrapper'], function (method) {
          inputs.autocomplete[method] = function () {
            var methodArguments = arguments;
            var result;
            inputs.each(function (j, input) {
              var typeahead = zepto(input).data(typeaheadKey);
              result = typeahead[method].apply(typeahead, methodArguments);
            });
            return result;
          };
        });
        return inputs;
      }
      autocomplete.sources = Typeahead.sources;
      autocomplete.escapeHighlightedString = _.escapeHighlightedString;
      var wasAutocompleteSet = 'autocomplete' in window;
      var oldAutocomplete = window.autocomplete;
      autocomplete.noConflict = function noConflict() {
        if (wasAutocompleteSet) {
          window.autocomplete = oldAutocomplete;
        } else {
          delete window.autocomplete;
        }
        return autocomplete;
      };
      module.exports = autocomplete;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var attrsKey = 'aaAttrs';
      var _ = __webpack_require__(0);
      var DOM = __webpack_require__(1);
      var EventBus = __webpack_require__(16);
      var Input = __webpack_require__(52);
      var Dropdown = __webpack_require__(59);
      var html = __webpack_require__(17);
      var css = __webpack_require__(11);
      function Typeahead(o) {
        var $menu;
        var $hint;
        o = o || {};
        if (!o.input) {
          _.error('missing input');
        }
        this.isActivated = false;
        this.debug = !!o.debug;
        this.autoselect = !!o.autoselect;
        this.autoselectOnBlur = !!o.autoselectOnBlur;
        this.openOnFocus = !!o.openOnFocus;
        this.minLength = _.isNumber(o.minLength) ? o.minLength : 1;
        this.autoWidth = o.autoWidth === undefined ? true : !!o.autoWidth;
        this.clearOnSelected = !!o.clearOnSelected;
        this.tabAutocomplete = o.tabAutocomplete === undefined ? true : !!o.tabAutocomplete;
        o.hint = !!o.hint;
        if (o.hint && o.appendTo) {
          throw new Error(
            "[autocomplete.js] hint and appendTo options can't be used at the same time",
          );
        }
        this.css = o.css = _.mixin({}, css, o.appendTo ? css.appendTo : {});
        this.cssClasses = o.cssClasses = _.mixin({}, css.defaultClasses, o.cssClasses || {});
        this.cssClasses.prefix = o.cssClasses.formattedPrefix = _.formatPrefix(
          this.cssClasses.prefix,
          this.cssClasses.noPrefix,
        );
        this.listboxId = o.listboxId = [this.cssClasses.root, 'listbox', _.getUniqueId()].join('-');
        var domElts = buildDom(o);
        this.$node = domElts.wrapper;
        var $input = (this.$input = domElts.input);
        $menu = domElts.menu;
        $hint = domElts.hint;
        if (o.dropdownMenuContainer) {
          DOM.element(o.dropdownMenuContainer)
            .css('position', 'relative')
            .append($menu.css('top', '0'));
        }
        $input.on('blur.aa', function ($e) {
          var active = document.activeElement;
          if (_.isMsie() && ($menu[0] === active || $menu[0].contains(active))) {
            $e.preventDefault();
            $e.stopImmediatePropagation();
            _.defer(function () {
              $input.focus();
            });
          }
        });
        $menu.on('mousedown.aa', function ($e) {
          $e.preventDefault();
        });
        this.eventBus = o.eventBus || new EventBus({ el: $input });
        this.dropdown = new Typeahead.Dropdown({
          appendTo: o.appendTo,
          wrapper: this.$node,
          menu: $menu,
          datasets: o.datasets,
          templates: o.templates,
          cssClasses: o.cssClasses,
          minLength: this.minLength,
        })
          .onSync('suggestionClicked', this._onSuggestionClicked, this)
          .onSync('cursorMoved', this._onCursorMoved, this)
          .onSync('cursorRemoved', this._onCursorRemoved, this)
          .onSync('opened', this._onOpened, this)
          .onSync('closed', this._onClosed, this)
          .onSync('shown', this._onShown, this)
          .onSync('empty', this._onEmpty, this)
          .onSync('redrawn', this._onRedrawn, this)
          .onAsync('datasetRendered', this._onDatasetRendered, this);
        this.input = new Typeahead.Input({ input: $input, hint: $hint })
          .onSync('focused', this._onFocused, this)
          .onSync('blurred', this._onBlurred, this)
          .onSync('enterKeyed', this._onEnterKeyed, this)
          .onSync('tabKeyed', this._onTabKeyed, this)
          .onSync('escKeyed', this._onEscKeyed, this)
          .onSync('upKeyed', this._onUpKeyed, this)
          .onSync('downKeyed', this._onDownKeyed, this)
          .onSync('leftKeyed', this._onLeftKeyed, this)
          .onSync('rightKeyed', this._onRightKeyed, this)
          .onSync('queryChanged', this._onQueryChanged, this)
          .onSync('whitespaceChanged', this._onWhitespaceChanged, this);
        this._bindKeyboardShortcuts(o);
        this._setLanguageDirection();
      }
      _.mixin(Typeahead.prototype, {
        _bindKeyboardShortcuts: function (options) {
          if (!options.keyboardShortcuts) {
            return;
          }
          var $input = this.$input;
          var keyboardShortcuts = [];
          _.each(options.keyboardShortcuts, function (key) {
            if (typeof key === 'string') {
              key = key.toUpperCase().charCodeAt(0);
            }
            keyboardShortcuts.push(key);
          });
          DOM.element(document).keydown(function (event) {
            var elt = event.target || event.srcElement;
            var tagName = elt.tagName;
            if (
              elt.isContentEditable ||
              tagName === 'INPUT' ||
              tagName === 'SELECT' ||
              tagName === 'TEXTAREA'
            ) {
              return;
            }
            var which = event.which || event.keyCode;
            if (keyboardShortcuts.indexOf(which) === -1) {
              return;
            }
            $input.focus();
            event.stopPropagation();
            event.preventDefault();
          });
        },
        _onSuggestionClicked: function onSuggestionClicked(type, $el) {
          var datum;
          var context = { selectionMethod: 'click' };
          if ((datum = this.dropdown.getDatumForSuggestion($el))) {
            this._select(datum, context);
          }
        },
        _onCursorMoved: function onCursorMoved(event, updateInput) {
          var datum = this.dropdown.getDatumForCursor();
          var currentCursorId = this.dropdown.getCurrentCursor().attr('id');
          this.input.setActiveDescendant(currentCursorId);
          if (datum) {
            if (updateInput) {
              this.input.setInputValue(datum.value, true);
            }
            this.eventBus.trigger('cursorchanged', datum.raw, datum.datasetName);
          }
        },
        _onCursorRemoved: function onCursorRemoved() {
          this.input.resetInputValue();
          this._updateHint();
          this.eventBus.trigger('cursorremoved');
        },
        _onDatasetRendered: function onDatasetRendered() {
          this._updateHint();
          this.eventBus.trigger('updated');
        },
        _onOpened: function onOpened() {
          this._updateHint();
          this.input.expand();
          this.eventBus.trigger('opened');
        },
        _onEmpty: function onEmpty() {
          this.eventBus.trigger('empty');
        },
        _onRedrawn: function onRedrawn() {
          this.$node.css('top', 0 + 'px');
          this.$node.css('left', 0 + 'px');
          var inputRect = this.$input[0].getBoundingClientRect();
          if (this.autoWidth) {
            this.$node.css('width', inputRect.width + 'px');
          }
          var wrapperRect = this.$node[0].getBoundingClientRect();
          var top = inputRect.bottom - wrapperRect.top;
          this.$node.css('top', top + 'px');
          var left = inputRect.left - wrapperRect.left;
          this.$node.css('left', left + 'px');
          this.eventBus.trigger('redrawn');
        },
        _onShown: function onShown() {
          this.eventBus.trigger('shown');
          if (this.autoselect) {
            this.dropdown.cursorTopSuggestion();
          }
        },
        _onClosed: function onClosed() {
          this.input.clearHint();
          this.input.removeActiveDescendant();
          this.input.collapse();
          this.eventBus.trigger('closed');
        },
        _onFocused: function onFocused() {
          this.isActivated = true;
          if (this.openOnFocus) {
            var query = this.input.getQuery();
            if (query.length >= this.minLength) {
              this.dropdown.update(query);
            } else {
              this.dropdown.empty();
            }
            this.dropdown.open();
          }
        },
        _onBlurred: function onBlurred() {
          var cursorDatum;
          var topSuggestionDatum;
          cursorDatum = this.dropdown.getDatumForCursor();
          topSuggestionDatum = this.dropdown.getDatumForTopSuggestion();
          var context = { selectionMethod: 'blur' };
          if (!this.debug) {
            if (this.autoselectOnBlur && cursorDatum) {
              this._select(cursorDatum, context);
            } else if (this.autoselectOnBlur && topSuggestionDatum) {
              this._select(topSuggestionDatum, context);
            } else {
              this.isActivated = false;
              this.dropdown.empty();
              this.dropdown.close();
            }
          }
        },
        _onEnterKeyed: function onEnterKeyed(type, $e) {
          var cursorDatum;
          var topSuggestionDatum;
          cursorDatum = this.dropdown.getDatumForCursor();
          topSuggestionDatum = this.dropdown.getDatumForTopSuggestion();
          var context = { selectionMethod: 'enterKey' };
          if (cursorDatum) {
            this._select(cursorDatum, context);
            $e.preventDefault();
          } else if (this.autoselect && topSuggestionDatum) {
            this._select(topSuggestionDatum, context);
            $e.preventDefault();
          }
        },
        _onTabKeyed: function onTabKeyed(type, $e) {
          if (!this.tabAutocomplete) {
            this.dropdown.close();
            return;
          }
          var datum;
          var context = { selectionMethod: 'tabKey' };
          if ((datum = this.dropdown.getDatumForCursor())) {
            this._select(datum, context);
            $e.preventDefault();
          } else {
            this._autocomplete(true);
          }
        },
        _onEscKeyed: function onEscKeyed() {
          this.dropdown.close();
          this.input.resetInputValue();
        },
        _onUpKeyed: function onUpKeyed() {
          var query = this.input.getQuery();
          if (this.dropdown.isEmpty && query.length >= this.minLength) {
            this.dropdown.update(query);
          } else {
            this.dropdown.moveCursorUp();
          }
          this.dropdown.open();
        },
        _onDownKeyed: function onDownKeyed() {
          var query = this.input.getQuery();
          if (this.dropdown.isEmpty && query.length >= this.minLength) {
            this.dropdown.update(query);
          } else {
            this.dropdown.moveCursorDown();
          }
          this.dropdown.open();
        },
        _onLeftKeyed: function onLeftKeyed() {
          if (this.dir === 'rtl') {
            this._autocomplete();
          }
        },
        _onRightKeyed: function onRightKeyed() {
          if (this.dir === 'ltr') {
            this._autocomplete();
          }
        },
        _onQueryChanged: function onQueryChanged(e, query) {
          this.input.clearHintIfInvalid();
          if (query.length >= this.minLength) {
            this.dropdown.update(query);
          } else {
            this.dropdown.empty();
          }
          this.dropdown.open();
          this._setLanguageDirection();
        },
        _onWhitespaceChanged: function onWhitespaceChanged() {
          this._updateHint();
          this.dropdown.open();
        },
        _setLanguageDirection: function setLanguageDirection() {
          var dir = this.input.getLanguageDirection();
          if (this.dir !== dir) {
            this.dir = dir;
            this.$node.css('direction', dir);
            this.dropdown.setLanguageDirection(dir);
          }
        },
        _updateHint: function updateHint() {
          var datum;
          var val;
          var query;
          var escapedQuery;
          var frontMatchRegEx;
          var match;
          datum = this.dropdown.getDatumForTopSuggestion();
          if (datum && this.dropdown.isVisible() && !this.input.hasOverflow()) {
            val = this.input.getInputValue();
            query = Input.normalizeQuery(val);
            escapedQuery = _.escapeRegExChars(query);
            frontMatchRegEx = new RegExp('^(?:' + escapedQuery + ')(.+$)', 'i');
            match = frontMatchRegEx.exec(datum.value);
            if (match) {
              this.input.setHint(val + match[1]);
            } else {
              this.input.clearHint();
            }
          } else {
            this.input.clearHint();
          }
        },
        _autocomplete: function autocomplete(laxCursor) {
          var hint;
          var query;
          var isCursorAtEnd;
          var datum;
          hint = this.input.getHint();
          query = this.input.getQuery();
          isCursorAtEnd = laxCursor || this.input.isCursorAtEnd();
          if (hint && query !== hint && isCursorAtEnd) {
            datum = this.dropdown.getDatumForTopSuggestion();
            if (datum) {
              this.input.setInputValue(datum.value);
            }
            this.eventBus.trigger('autocompleted', datum.raw, datum.datasetName);
          }
        },
        _select: function select(datum, context) {
          if (typeof datum.value !== 'undefined') {
            this.input.setQuery(datum.value);
          }
          if (this.clearOnSelected) {
            this.setVal('');
          } else {
            this.input.setInputValue(datum.value, true);
          }
          this._setLanguageDirection();
          var event = this.eventBus.trigger('selected', datum.raw, datum.datasetName, context);
          if (event.isDefaultPrevented() === false) {
            this.dropdown.close();
            _.defer(_.bind(this.dropdown.empty, this.dropdown));
          }
        },
        open: function open() {
          if (!this.isActivated) {
            var query = this.input.getInputValue();
            if (query.length >= this.minLength) {
              this.dropdown.update(query);
            } else {
              this.dropdown.empty();
            }
          }
          this.dropdown.open();
        },
        close: function close() {
          this.dropdown.close();
        },
        setVal: function setVal(val) {
          val = _.toStr(val);
          if (this.isActivated) {
            this.input.setInputValue(val);
          } else {
            this.input.setQuery(val);
            this.input.setInputValue(val, true);
          }
          this._setLanguageDirection();
        },
        getVal: function getVal() {
          return this.input.getQuery();
        },
        destroy: function destroy() {
          this.input.destroy();
          this.dropdown.destroy();
          destroyDomStructure(this.$node, this.cssClasses);
          this.$node = null;
        },
        getWrapper: function getWrapper() {
          return this.dropdown.$container[0];
        },
      });
      function buildDom(options) {
        var $input;
        var $wrapper;
        var $dropdown;
        var $hint;
        $input = DOM.element(options.input);
        $wrapper = DOM.element(html.wrapper.replace('%ROOT%', options.cssClasses.root)).css(
          options.css.wrapper,
        );
        if (
          !options.appendTo &&
          $input.css('display') === 'block' &&
          $input.parent().css('display') === 'table'
        ) {
          $wrapper.css('display', 'table-cell');
        }
        var dropdownHtml = html.dropdown
          .replace('%PREFIX%', options.cssClasses.prefix)
          .replace('%DROPDOWN_MENU%', options.cssClasses.dropdownMenu);
        $dropdown = DOM.element(dropdownHtml)
          .css(options.css.dropdown)
          .attr({ role: 'listbox', id: options.listboxId });
        if (options.templates && options.templates.dropdownMenu) {
          $dropdown.html(_.templatify(options.templates.dropdownMenu)());
        }
        $hint = $input.clone().css(options.css.hint).css(getBackgroundStyles($input));
        $hint
          .val('')
          .addClass(_.className(options.cssClasses.prefix, options.cssClasses.hint, true))
          .removeAttr('id name placeholder required')
          .prop('readonly', true)
          .attr({ 'aria-hidden': 'true', autocomplete: 'off', spellcheck: 'false', tabindex: -1 });
        if ($hint.removeData) {
          $hint.removeData();
        }
        $input.data(attrsKey, {
          'aria-autocomplete': $input.attr('aria-autocomplete'),
          'aria-expanded': $input.attr('aria-expanded'),
          'aria-owns': $input.attr('aria-owns'),
          autocomplete: $input.attr('autocomplete'),
          dir: $input.attr('dir'),
          role: $input.attr('role'),
          spellcheck: $input.attr('spellcheck'),
          style: $input.attr('style'),
          type: $input.attr('type'),
        });
        $input
          .addClass(_.className(options.cssClasses.prefix, options.cssClasses.input, true))
          .attr({
            autocomplete: 'off',
            spellcheck: false,
            role: 'combobox',
            'aria-autocomplete':
              options.datasets && options.datasets[0] && options.datasets[0].displayKey
                ? 'both'
                : 'list',
            'aria-expanded': 'false',
            'aria-label': options.ariaLabel,
            'aria-owns': options.listboxId,
          })
          .css(options.hint ? options.css.input : options.css.inputWithNoHint);
        try {
          if (!$input.attr('dir')) {
            $input.attr('dir', 'auto');
          }
        } catch (e) {}
        $wrapper = options.appendTo
          ? $wrapper.appendTo(DOM.element(options.appendTo).eq(0)).eq(0)
          : $input.wrap($wrapper).parent();
        $wrapper.prepend(options.hint ? $hint : null).append($dropdown);
        return { wrapper: $wrapper, input: $input, hint: $hint, menu: $dropdown };
      }
      function getBackgroundStyles($el) {
        return {
          backgroundAttachment: $el.css('background-attachment'),
          backgroundClip: $el.css('background-clip'),
          backgroundColor: $el.css('background-color'),
          backgroundImage: $el.css('background-image'),
          backgroundOrigin: $el.css('background-origin'),
          backgroundPosition: $el.css('background-position'),
          backgroundRepeat: $el.css('background-repeat'),
          backgroundSize: $el.css('background-size'),
        };
      }
      function destroyDomStructure($node, cssClasses) {
        var $input = $node.find(_.className(cssClasses.prefix, cssClasses.input));
        _.each($input.data(attrsKey), function (val, key) {
          if (val === undefined) {
            $input.removeAttr(key);
          } else {
            $input.attr(key, val);
          }
        });
        $input
          .detach()
          .removeClass(_.className(cssClasses.prefix, cssClasses.input, true))
          .insertAfter($node);
        if ($input.removeData) {
          $input.removeData(attrsKey);
        }
        $node.remove();
      }
      Typeahead.Dropdown = Dropdown;
      Typeahead.Input = Input;
      Typeahead.sources = __webpack_require__(61);
      module.exports = Typeahead;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var specialKeyCodeMap;
      specialKeyCodeMap = {
        9: 'tab',
        27: 'esc',
        37: 'left',
        39: 'right',
        13: 'enter',
        38: 'up',
        40: 'down',
      };
      var _ = __webpack_require__(0);
      var DOM = __webpack_require__(1);
      var EventEmitter = __webpack_require__(10);
      function Input(o) {
        var that = this;
        var onBlur;
        var onFocus;
        var onKeydown;
        var onInput;
        o = o || {};
        if (!o.input) {
          _.error('input is missing');
        }
        onBlur = _.bind(this._onBlur, this);
        onFocus = _.bind(this._onFocus, this);
        onKeydown = _.bind(this._onKeydown, this);
        onInput = _.bind(this._onInput, this);
        this.$hint = DOM.element(o.hint);
        this.$input = DOM.element(o.input)
          .on('blur.aa', onBlur)
          .on('focus.aa', onFocus)
          .on('keydown.aa', onKeydown);
        if (this.$hint.length === 0) {
          this.setHint = this.getHint = this.clearHint = this.clearHintIfInvalid = _.noop;
        }
        if (!_.isMsie()) {
          this.$input.on('input.aa', onInput);
        } else {
          this.$input.on('keydown.aa keypress.aa cut.aa paste.aa', function ($e) {
            if (specialKeyCodeMap[$e.which || $e.keyCode]) {
              return;
            }
            _.defer(_.bind(that._onInput, that, $e));
          });
        }
        this.query = this.$input.val();
        this.$overflowHelper = buildOverflowHelper(this.$input);
      }
      Input.normalizeQuery = function (str) {
        return (str || '').replace(/^\s*/g, '').replace(/\s{2,}/g, ' ');
      };
      _.mixin(Input.prototype, EventEmitter, {
        _onBlur: function onBlur() {
          this.resetInputValue();
          this.$input.removeAttr('aria-activedescendant');
          this.trigger('blurred');
        },
        _onFocus: function onFocus() {
          this.trigger('focused');
        },
        _onKeydown: function onKeydown($e) {
          var keyName = specialKeyCodeMap[$e.which || $e.keyCode];
          this._managePreventDefault(keyName, $e);
          if (keyName && this._shouldTrigger(keyName, $e)) {
            this.trigger(keyName + 'Keyed', $e);
          }
        },
        _onInput: function onInput() {
          this._checkInputValue();
        },
        _managePreventDefault: function managePreventDefault(keyName, $e) {
          var preventDefault;
          var hintValue;
          var inputValue;
          switch (keyName) {
            case 'tab':
              hintValue = this.getHint();
              inputValue = this.getInputValue();
              preventDefault = hintValue && hintValue !== inputValue && !withModifier($e);
              break;
            case 'up':
            case 'down':
              preventDefault = !withModifier($e);
              break;
            default:
              preventDefault = false;
          }
          if (preventDefault) {
            $e.preventDefault();
          }
        },
        _shouldTrigger: function shouldTrigger(keyName, $e) {
          var trigger;
          switch (keyName) {
            case 'tab':
              trigger = !withModifier($e);
              break;
            default:
              trigger = true;
          }
          return trigger;
        },
        _checkInputValue: function checkInputValue() {
          var inputValue;
          var areEquivalent;
          var hasDifferentWhitespace;
          inputValue = this.getInputValue();
          areEquivalent = areQueriesEquivalent(inputValue, this.query);
          hasDifferentWhitespace =
            areEquivalent && this.query ? this.query.length !== inputValue.length : false;
          this.query = inputValue;
          if (!areEquivalent) {
            this.trigger('queryChanged', this.query);
          } else if (hasDifferentWhitespace) {
            this.trigger('whitespaceChanged', this.query);
          }
        },
        focus: function focus() {
          this.$input.focus();
        },
        blur: function blur() {
          this.$input.blur();
        },
        getQuery: function getQuery() {
          return this.query;
        },
        setQuery: function setQuery(query) {
          this.query = query;
        },
        getInputValue: function getInputValue() {
          return this.$input.val();
        },
        setInputValue: function setInputValue(value, silent) {
          if (typeof value === 'undefined') {
            value = this.query;
          }
          this.$input.val(value);
          if (silent) {
            this.clearHint();
          } else {
            this._checkInputValue();
          }
        },
        expand: function expand() {
          this.$input.attr('aria-expanded', 'true');
        },
        collapse: function collapse() {
          this.$input.attr('aria-expanded', 'false');
        },
        setActiveDescendant: function setActiveDescendant(activedescendantId) {
          this.$input.attr('aria-activedescendant', activedescendantId);
        },
        removeActiveDescendant: function removeActiveDescendant() {
          this.$input.removeAttr('aria-activedescendant');
        },
        resetInputValue: function resetInputValue() {
          this.setInputValue(this.query, true);
        },
        getHint: function getHint() {
          return this.$hint.val();
        },
        setHint: function setHint(value) {
          this.$hint.val(value);
        },
        clearHint: function clearHint() {
          this.setHint('');
        },
        clearHintIfInvalid: function clearHintIfInvalid() {
          var val;
          var hint;
          var valIsPrefixOfHint;
          var isValid;
          val = this.getInputValue();
          hint = this.getHint();
          valIsPrefixOfHint = val !== hint && hint.indexOf(val) === 0;
          isValid = val !== '' && valIsPrefixOfHint && !this.hasOverflow();
          if (!isValid) {
            this.clearHint();
          }
        },
        getLanguageDirection: function getLanguageDirection() {
          return (this.$input.css('direction') || 'ltr').toLowerCase();
        },
        hasOverflow: function hasOverflow() {
          var constraint = this.$input.width() - 2;
          this.$overflowHelper.text(this.getInputValue());
          return this.$overflowHelper.width() >= constraint;
        },
        isCursorAtEnd: function () {
          var valueLength;
          var selectionStart;
          var range;
          valueLength = this.$input.val().length;
          selectionStart = this.$input[0].selectionStart;
          if (_.isNumber(selectionStart)) {
            return selectionStart === valueLength;
          } else if (document.selection) {
            range = document.selection.createRange();
            range.moveStart('character', -valueLength);
            return valueLength === range.text.length;
          }
          return true;
        },
        destroy: function destroy() {
          this.$hint.off('.aa');
          this.$input.off('.aa');
          this.$hint = this.$input = this.$overflowHelper = null;
        },
      });
      function buildOverflowHelper($input) {
        return DOM.element('<pre aria-hidden="true"></pre>')
          .css({
            position: 'absolute',
            visibility: 'hidden',
            whiteSpace: 'pre',
            fontFamily: $input.css('font-family'),
            fontSize: $input.css('font-size'),
            fontStyle: $input.css('font-style'),
            fontVariant: $input.css('font-variant'),
            fontWeight: $input.css('font-weight'),
            wordSpacing: $input.css('word-spacing'),
            letterSpacing: $input.css('letter-spacing'),
            textIndent: $input.css('text-indent'),
            textRendering: $input.css('text-rendering'),
            textTransform: $input.css('text-transform'),
          })
          .insertAfter($input);
      }
      function areQueriesEquivalent(a, b) {
        return Input.normalizeQuery(a) === Input.normalizeQuery(b);
      }
      function withModifier($e) {
        return $e.altKey || $e.ctrlKey || $e.metaKey || $e.shiftKey;
      }
      module.exports = Input;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var types = [
        __webpack_require__(54),
        __webpack_require__(55),
        __webpack_require__(56),
        __webpack_require__(57),
        __webpack_require__(58),
      ];
      var draining;
      var currentQueue;
      var queueIndex = -1;
      var queue = [];
      var scheduled = false;
      function cleanUpNextTick() {
        if (!draining || !currentQueue) {
          return;
        }
        draining = false;
        if (currentQueue.length) {
          queue = currentQueue.concat(queue);
        } else {
          queueIndex = -1;
        }
        if (queue.length) {
          nextTick();
        }
      }
      function nextTick() {
        if (draining) {
          return;
        }
        scheduled = false;
        draining = true;
        var len = queue.length;
        var timeout = setTimeout(cleanUpNextTick);
        while (len) {
          currentQueue = queue;
          queue = [];
          while (currentQueue && ++queueIndex < len) {
            currentQueue[queueIndex].run();
          }
          queueIndex = -1;
          len = queue.length;
        }
        currentQueue = null;
        queueIndex = -1;
        draining = false;
        clearTimeout(timeout);
      }
      var scheduleDrain;
      var i = -1;
      var len = types.length;
      while (++i < len) {
        if (types[i] && types[i].test && types[i].test()) {
          scheduleDrain = types[i].install(nextTick);
          break;
        }
      }
      function Item(fun, array) {
        this.fun = fun;
        this.array = array;
      }
      Item.prototype.run = function () {
        var fun = this.fun;
        var array = this.array;
        switch (array.length) {
          case 0:
            return fun();
          case 1:
            return fun(array[0]);
          case 2:
            return fun(array[0], array[1]);
          case 3:
            return fun(array[0], array[1], array[2]);
          default:
            return fun.apply(null, array);
        }
      };
      module.exports = immediate;
      function immediate(task) {
        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(task, args));
        if (!scheduled && !draining) {
          scheduled = true;
          scheduleDrain();
        }
      }
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      (function (process) {
        exports.test = function () {
          return typeof process !== 'undefined' && !process.browser;
        };
        exports.install = function (func) {
          return function () {
            process.nextTick(func);
          };
        };
      }).call(exports, __webpack_require__(9));
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      (function (global) {
        var Mutation = global.MutationObserver || global.WebKitMutationObserver;
        exports.test = function () {
          return Mutation;
        };
        exports.install = function (handle) {
          var called = 0;
          var observer = new Mutation(handle);
          var element = global.document.createTextNode('');
          observer.observe(element, { characterData: true });
          return function () {
            element.data = called = ++called % 2;
          };
        };
      }).call(exports, __webpack_require__(4));
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      (function (global) {
        exports.test = function () {
          if (global.setImmediate) {
            return false;
          }
          return typeof global.MessageChannel !== 'undefined';
        };
        exports.install = function (func) {
          var channel = new global.MessageChannel();
          channel.port1.onmessage = func;
          return function () {
            channel.port2.postMessage(0);
          };
        };
      }).call(exports, __webpack_require__(4));
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      (function (global) {
        exports.test = function () {
          return (
            'document' in global && 'onreadystatechange' in global.document.createElement('script')
          );
        };
        exports.install = function (handle) {
          return function () {
            var scriptEl = global.document.createElement('script');
            scriptEl.onreadystatechange = function () {
              handle();
              scriptEl.onreadystatechange = null;
              scriptEl.parentNode.removeChild(scriptEl);
              scriptEl = null;
            };
            global.document.documentElement.appendChild(scriptEl);
            return handle;
          };
        };
      }).call(exports, __webpack_require__(4));
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      exports.test = function () {
        return true;
      };
      exports.install = function (t) {
        return function () {
          setTimeout(t, 0);
        };
      };
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var _ = __webpack_require__(0);
      var DOM = __webpack_require__(1);
      var EventEmitter = __webpack_require__(10);
      var Dataset = __webpack_require__(60);
      var css = __webpack_require__(11);
      function Dropdown(o) {
        var that = this;
        var onSuggestionClick;
        var onSuggestionMouseEnter;
        var onSuggestionMouseLeave;
        o = o || {};
        if (!o.menu) {
          _.error('menu is required');
        }
        if (!_.isArray(o.datasets) && !_.isObject(o.datasets)) {
          _.error('1 or more datasets required');
        }
        if (!o.datasets) {
          _.error('datasets is required');
        }
        this.isOpen = false;
        this.isEmpty = true;
        this.minLength = o.minLength || 0;
        this.templates = {};
        this.appendTo = o.appendTo || false;
        this.css = _.mixin({}, css, o.appendTo ? css.appendTo : {});
        this.cssClasses = o.cssClasses = _.mixin({}, css.defaultClasses, o.cssClasses || {});
        this.cssClasses.prefix =
          o.cssClasses.formattedPrefix ||
          _.formatPrefix(this.cssClasses.prefix, this.cssClasses.noPrefix);
        onSuggestionClick = _.bind(this._onSuggestionClick, this);
        onSuggestionMouseEnter = _.bind(this._onSuggestionMouseEnter, this);
        onSuggestionMouseLeave = _.bind(this._onSuggestionMouseLeave, this);
        var cssClass = _.className(this.cssClasses.prefix, this.cssClasses.suggestion);
        this.$menu = DOM.element(o.menu)
          .on('mouseenter.aa', cssClass, onSuggestionMouseEnter)
          .on('mouseleave.aa', cssClass, onSuggestionMouseLeave)
          .on('click.aa', cssClass, onSuggestionClick);
        this.$container = o.appendTo ? o.wrapper : this.$menu;
        if (o.templates && o.templates.header) {
          this.templates.header = _.templatify(o.templates.header);
          this.$menu.prepend(this.templates.header());
        }
        if (o.templates && o.templates.empty) {
          this.templates.empty = _.templatify(o.templates.empty);
          this.$empty = DOM.element(
            '<div class="' +
              _.className(this.cssClasses.prefix, this.cssClasses.empty, true) +
              '">' +
              '</div>',
          );
          this.$menu.append(this.$empty);
          this.$empty.hide();
        }
        this.datasets = _.map(o.datasets, function (oDataset) {
          return initializeDataset(that.$menu, oDataset, o.cssClasses);
        });
        _.each(this.datasets, function (dataset) {
          var root = dataset.getRoot();
          if (root && root.parent().length === 0) {
            that.$menu.append(root);
          }
          dataset.onSync('rendered', that._onRendered, that);
        });
        if (o.templates && o.templates.footer) {
          this.templates.footer = _.templatify(o.templates.footer);
          this.$menu.append(this.templates.footer());
        }
        var self = this;
        DOM.element(window).resize(function () {
          self._redraw();
        });
      }
      _.mixin(Dropdown.prototype, EventEmitter, {
        _onSuggestionClick: function onSuggestionClick($e) {
          this.trigger('suggestionClicked', DOM.element($e.currentTarget));
        },
        _onSuggestionMouseEnter: function onSuggestionMouseEnter($e) {
          var elt = DOM.element($e.currentTarget);
          if (elt.hasClass(_.className(this.cssClasses.prefix, this.cssClasses.cursor, true))) {
            return;
          }
          this._removeCursor();
          var suggestion = this;
          setTimeout(function () {
            suggestion._setCursor(elt, false);
          }, 0);
        },
        _onSuggestionMouseLeave: function onSuggestionMouseLeave($e) {
          if ($e.relatedTarget) {
            var elt = DOM.element($e.relatedTarget);
            if (
              elt.closest('.' + _.className(this.cssClasses.prefix, this.cssClasses.cursor, true))
                .length > 0
            ) {
              return;
            }
          }
          this._removeCursor();
          this.trigger('cursorRemoved');
        },
        _onRendered: function onRendered(e, query) {
          this.isEmpty = _.every(this.datasets, isDatasetEmpty);
          if (this.isEmpty) {
            if (query.length >= this.minLength) {
              this.trigger('empty');
            }
            if (this.$empty) {
              if (query.length < this.minLength) {
                this._hide();
              } else {
                var html = this.templates.empty({
                  query: this.datasets[0] && this.datasets[0].query,
                });
                this.$empty.html(html);
                this.$empty.show();
                this._show();
              }
            } else if (_.any(this.datasets, hasEmptyTemplate)) {
              if (query.length < this.minLength) {
                this._hide();
              } else {
                this._show();
              }
            } else {
              this._hide();
            }
          } else if (this.isOpen) {
            if (this.$empty) {
              this.$empty.empty();
              this.$empty.hide();
            }
            if (query.length >= this.minLength) {
              this._show();
            } else {
              this._hide();
            }
          }
          this.trigger('datasetRendered');
          function isDatasetEmpty(dataset) {
            return dataset.isEmpty();
          }
          function hasEmptyTemplate(dataset) {
            return dataset.templates && dataset.templates.empty;
          }
        },
        _hide: function () {
          this.$container.hide();
        },
        _show: function () {
          this.$container.css('display', 'block');
          this._redraw();
          this.trigger('shown');
        },
        _redraw: function redraw() {
          if (!this.isOpen || !this.appendTo) return;
          this.trigger('redrawn');
        },
        _getSuggestions: function getSuggestions() {
          return this.$menu.find(_.className(this.cssClasses.prefix, this.cssClasses.suggestion));
        },
        _getCursor: function getCursor() {
          return this.$menu
            .find(_.className(this.cssClasses.prefix, this.cssClasses.cursor))
            .first();
        },
        _setCursor: function setCursor($el, updateInput) {
          $el
            .first()
            .addClass(_.className(this.cssClasses.prefix, this.cssClasses.cursor, true))
            .attr('aria-selected', 'true');
          this.trigger('cursorMoved', updateInput);
        },
        _removeCursor: function removeCursor() {
          this._getCursor()
            .removeClass(_.className(this.cssClasses.prefix, this.cssClasses.cursor, true))
            .removeAttr('aria-selected');
        },
        _moveCursor: function moveCursor(increment) {
          var $suggestions;
          var $oldCursor;
          var newCursorIndex;
          var $newCursor;
          if (!this.isOpen) {
            return;
          }
          $oldCursor = this._getCursor();
          $suggestions = this._getSuggestions();
          this._removeCursor();
          newCursorIndex = $suggestions.index($oldCursor) + increment;
          newCursorIndex = ((newCursorIndex + 1) % ($suggestions.length + 1)) - 1;
          if (newCursorIndex === -1) {
            this.trigger('cursorRemoved');
            return;
          } else if (newCursorIndex < -1) {
            newCursorIndex = $suggestions.length - 1;
          }
          this._setCursor(($newCursor = $suggestions.eq(newCursorIndex)), true);
          this._ensureVisible($newCursor);
        },
        _ensureVisible: function ensureVisible($el) {
          var elTop;
          var elBottom;
          var menuScrollTop;
          var menuHeight;
          elTop = $el.position().top;
          elBottom =
            elTop +
            $el.height() +
            parseInt($el.css('margin-top'), 10) +
            parseInt($el.css('margin-bottom'), 10);
          menuScrollTop = this.$menu.scrollTop();
          menuHeight =
            this.$menu.height() +
            parseInt(this.$menu.css('padding-top'), 10) +
            parseInt(this.$menu.css('padding-bottom'), 10);
          if (elTop < 0) {
            this.$menu.scrollTop(menuScrollTop + elTop);
          } else if (menuHeight < elBottom) {
            this.$menu.scrollTop(menuScrollTop + (elBottom - menuHeight));
          }
        },
        close: function close() {
          if (this.isOpen) {
            this.isOpen = false;
            this._removeCursor();
            this._hide();
            this.trigger('closed');
          }
        },
        open: function open() {
          if (!this.isOpen) {
            this.isOpen = true;
            if (!this.isEmpty) {
              this._show();
            }
            this.trigger('opened');
          }
        },
        setLanguageDirection: function setLanguageDirection(dir) {
          this.$menu.css(dir === 'ltr' ? this.css.ltr : this.css.rtl);
        },
        moveCursorUp: function moveCursorUp() {
          this._moveCursor(-1);
        },
        moveCursorDown: function moveCursorDown() {
          this._moveCursor(+1);
        },
        getDatumForSuggestion: function getDatumForSuggestion($el) {
          var datum = null;
          if ($el.length) {
            datum = {
              raw: Dataset.extractDatum($el),
              value: Dataset.extractValue($el),
              datasetName: Dataset.extractDatasetName($el),
            };
          }
          return datum;
        },
        getCurrentCursor: function getCurrentCursor() {
          return this._getCursor().first();
        },
        getDatumForCursor: function getDatumForCursor() {
          return this.getDatumForSuggestion(this._getCursor().first());
        },
        getDatumForTopSuggestion: function getDatumForTopSuggestion() {
          return this.getDatumForSuggestion(this._getSuggestions().first());
        },
        cursorTopSuggestion: function cursorTopSuggestion() {
          this._setCursor(this._getSuggestions().first(), false);
        },
        update: function update(query) {
          _.each(this.datasets, updateDataset);
          function updateDataset(dataset) {
            dataset.update(query);
          }
        },
        empty: function empty() {
          _.each(this.datasets, clearDataset);
          this.isEmpty = true;
          function clearDataset(dataset) {
            dataset.clear();
          }
        },
        isVisible: function isVisible() {
          return this.isOpen && !this.isEmpty;
        },
        destroy: function destroy() {
          this.$menu.off('.aa');
          this.$menu = null;
          _.each(this.datasets, destroyDataset);
          function destroyDataset(dataset) {
            dataset.destroy();
          }
        },
      });
      Dropdown.Dataset = Dataset;
      function initializeDataset($menu, oDataset, cssClasses) {
        return new Dropdown.Dataset(_.mixin({ $menu: $menu, cssClasses: cssClasses }, oDataset));
      }
      module.exports = Dropdown;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var datasetKey = 'aaDataset';
      var valueKey = 'aaValue';
      var datumKey = 'aaDatum';
      var _ = __webpack_require__(0);
      var DOM = __webpack_require__(1);
      var html = __webpack_require__(17);
      var css = __webpack_require__(11);
      var EventEmitter = __webpack_require__(10);
      function Dataset(o) {
        o = o || {};
        o.templates = o.templates || {};
        if (!o.source) {
          _.error('missing source');
        }
        if (o.name && !isValidName(o.name)) {
          _.error('invalid dataset name: ' + o.name);
        }
        this.query = null;
        this._isEmpty = true;
        this.highlight = !!o.highlight;
        this.name = typeof o.name === 'undefined' || o.name === null ? _.getUniqueId() : o.name;
        this.source = o.source;
        this.displayFn = getDisplayFn(o.display || o.displayKey);
        this.debounce = o.debounce;
        this.cache = o.cache !== false;
        this.templates = getTemplates(o.templates, this.displayFn);
        this.css = _.mixin({}, css, o.appendTo ? css.appendTo : {});
        this.cssClasses = o.cssClasses = _.mixin({}, css.defaultClasses, o.cssClasses || {});
        this.cssClasses.prefix =
          o.cssClasses.formattedPrefix ||
          _.formatPrefix(this.cssClasses.prefix, this.cssClasses.noPrefix);
        var clazz = _.className(this.cssClasses.prefix, this.cssClasses.dataset);
        this.$el =
          o.$menu && o.$menu.find(clazz + '-' + this.name).length > 0
            ? DOM.element(o.$menu.find(clazz + '-' + this.name)[0])
            : DOM.element(
                html.dataset
                  .replace('%CLASS%', this.name)
                  .replace('%PREFIX%', this.cssClasses.prefix)
                  .replace('%DATASET%', this.cssClasses.dataset),
              );
        this.$menu = o.$menu;
        this.clearCachedSuggestions();
      }
      Dataset.extractDatasetName = function extractDatasetName(el) {
        return DOM.element(el).data(datasetKey);
      };
      Dataset.extractValue = function extractValue(el) {
        return DOM.element(el).data(valueKey);
      };
      Dataset.extractDatum = function extractDatum(el) {
        var datum = DOM.element(el).data(datumKey);
        if (typeof datum === 'string') {
          datum = JSON.parse(datum);
        }
        return datum;
      };
      _.mixin(Dataset.prototype, EventEmitter, {
        _render: function render(query, suggestions) {
          if (!this.$el) {
            return;
          }
          var that = this;
          var hasSuggestions;
          var renderArgs = [].slice.call(arguments, 2);
          this.$el.empty();
          hasSuggestions = suggestions && suggestions.length;
          this._isEmpty = !hasSuggestions;
          if (!hasSuggestions && this.templates.empty) {
            this.$el
              .html(getEmptyHtml.apply(this, renderArgs))
              .prepend(that.templates.header ? getHeaderHtml.apply(this, renderArgs) : null)
              .append(that.templates.footer ? getFooterHtml.apply(this, renderArgs) : null);
          } else if (hasSuggestions) {
            this.$el
              .html(getSuggestionsHtml.apply(this, renderArgs))
              .prepend(that.templates.header ? getHeaderHtml.apply(this, renderArgs) : null)
              .append(that.templates.footer ? getFooterHtml.apply(this, renderArgs) : null);
          } else if (suggestions && !Array.isArray(suggestions)) {
            throw new TypeError('suggestions must be an array');
          }
          if (this.$menu) {
            this.$menu
              .addClass(
                this.cssClasses.prefix + (hasSuggestions ? 'with' : 'without') + '-' + this.name,
              )
              .removeClass(
                this.cssClasses.prefix + (hasSuggestions ? 'without' : 'with') + '-' + this.name,
              );
          }
          this.trigger('rendered', query);
          function getEmptyHtml() {
            var args = [].slice.call(arguments, 0);
            args = [{ query: query, isEmpty: true }].concat(args);
            return that.templates.empty.apply(this, args);
          }
          function getSuggestionsHtml() {
            var args = [].slice.call(arguments, 0);
            var $suggestions;
            var nodes;
            var self = this;
            var suggestionsHtml = html.suggestions
              .replace('%PREFIX%', this.cssClasses.prefix)
              .replace('%SUGGESTIONS%', this.cssClasses.suggestions);
            $suggestions = DOM.element(suggestionsHtml).css(this.css.suggestions);
            nodes = _.map(suggestions, getSuggestionNode);
            $suggestions.append.apply($suggestions, nodes);
            return $suggestions;
            function getSuggestionNode(suggestion) {
              var $el;
              var suggestionHtml = html.suggestion
                .replace('%PREFIX%', self.cssClasses.prefix)
                .replace('%SUGGESTION%', self.cssClasses.suggestion);
              $el = DOM.element(suggestionHtml)
                .attr({ role: 'option', id: ['option', Math.floor(Math.random() * 1e8)].join('-') })
                .append(that.templates.suggestion.apply(this, [suggestion].concat(args)));
              $el.data(datasetKey, that.name);
              $el.data(valueKey, that.displayFn(suggestion) || undefined);
              $el.data(datumKey, JSON.stringify(suggestion));
              $el.children().each(function () {
                DOM.element(this).css(self.css.suggestionChild);
              });
              return $el;
            }
          }
          function getHeaderHtml() {
            var args = [].slice.call(arguments, 0);
            args = [{ query: query, isEmpty: !hasSuggestions }].concat(args);
            return that.templates.header.apply(this, args);
          }
          function getFooterHtml() {
            var args = [].slice.call(arguments, 0);
            args = [{ query: query, isEmpty: !hasSuggestions }].concat(args);
            return that.templates.footer.apply(this, args);
          }
        },
        getRoot: function getRoot() {
          return this.$el;
        },
        update: function update(query) {
          function handleSuggestions(suggestions) {
            if (!this.canceled && query === this.query) {
              var extraArgs = [].slice.call(arguments, 1);
              this.cacheSuggestions(query, suggestions, extraArgs);
              this._render.apply(this, [query, suggestions].concat(extraArgs));
            }
          }
          this.query = query;
          this.canceled = false;
          if (this.shouldFetchFromCache(query)) {
            handleSuggestions.apply(
              this,
              [this.cachedSuggestions].concat(this.cachedRenderExtraArgs),
            );
          } else {
            var that = this;
            var execSource = function () {
              if (!that.canceled) {
                that.source(query, handleSuggestions.bind(that));
              }
            };
            if (this.debounce) {
              var later = function () {
                that.debounceTimeout = null;
                execSource();
              };
              clearTimeout(this.debounceTimeout);
              this.debounceTimeout = setTimeout(later, this.debounce);
            } else {
              execSource();
            }
          }
        },
        cacheSuggestions: function cacheSuggestions(query, suggestions, extraArgs) {
          this.cachedQuery = query;
          this.cachedSuggestions = suggestions;
          this.cachedRenderExtraArgs = extraArgs;
        },
        shouldFetchFromCache: function shouldFetchFromCache(query) {
          return (
            this.cache &&
            this.cachedQuery === query &&
            this.cachedSuggestions &&
            this.cachedSuggestions.length
          );
        },
        clearCachedSuggestions: function clearCachedSuggestions() {
          delete this.cachedQuery;
          delete this.cachedSuggestions;
          delete this.cachedRenderExtraArgs;
        },
        cancel: function cancel() {
          this.canceled = true;
        },
        clear: function clear() {
          this.cancel();
          this.$el.empty();
          this.trigger('rendered', '');
        },
        isEmpty: function isEmpty() {
          return this._isEmpty;
        },
        destroy: function destroy() {
          this.clearCachedSuggestions();
          this.$el = null;
        },
      });
      function getDisplayFn(display) {
        display = display || 'value';
        return _.isFunction(display) ? display : displayFn;
        function displayFn(obj) {
          return obj[display];
        }
      }
      function getTemplates(templates, displayFn) {
        return {
          empty: templates.empty && _.templatify(templates.empty),
          header: templates.header && _.templatify(templates.header),
          footer: templates.footer && _.templatify(templates.footer),
          suggestion: templates.suggestion || suggestionTemplate,
        };
        function suggestionTemplate(context) {
          return '<p>' + displayFn(context) + '</p>';
        }
      }
      function isValidName(str) {
        return /^[_a-zA-Z0-9-]+$/.test(str);
      }
      module.exports = Dataset;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      module.exports = { hits: __webpack_require__(62), popularIn: __webpack_require__(63) };
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var _ = __webpack_require__(0);
      var version = __webpack_require__(18);
      var parseAlgoliaClientVersion = __webpack_require__(19);
      module.exports = function search(index, params) {
        var algoliaVersion = parseAlgoliaClientVersion(index.as._ua);
        if (algoliaVersion && algoliaVersion[0] >= 3 && algoliaVersion[1] > 20) {
          params = params || {};
          params.additionalUA = 'autocomplete.js ' + version;
        }
        return sourceFn;
        function sourceFn(query, cb) {
          index.search(query, params, function (error, content) {
            if (error) {
              _.error(error.message);
              return;
            }
            cb(content.hits, content);
          });
        }
      };
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      var _ = __webpack_require__(0);
      var version = __webpack_require__(18);
      var parseAlgoliaClientVersion = __webpack_require__(19);
      module.exports = function popularIn(index, params, details, options) {
        var algoliaVersion = parseAlgoliaClientVersion(index.as._ua);
        if (algoliaVersion && algoliaVersion[0] >= 3 && algoliaVersion[1] > 20) {
          params = params || {};
          params.additionalUA = 'autocomplete.js ' + version;
        }
        if (!details.source) {
          return _.error("Missing 'source' key");
        }
        var source = _.isFunction(details.source)
          ? details.source
          : function (hit) {
              return hit[details.source];
            };
        if (!details.index) {
          return _.error("Missing 'index' key");
        }
        var detailsIndex = details.index;
        options = options || {};
        return sourceFn;
        function sourceFn(query, cb) {
          index.search(query, params, function (error, content) {
            if (error) {
              _.error(error.message);
              return;
            }
            if (content.hits.length > 0) {
              var first = content.hits[0];
              var detailsParams = _.mixin({ hitsPerPage: 0 }, details);
              delete detailsParams.source;
              delete detailsParams.index;
              var detailsAlgoliaVersion = parseAlgoliaClientVersion(detailsIndex.as._ua);
              if (
                detailsAlgoliaVersion &&
                detailsAlgoliaVersion[0] >= 3 &&
                detailsAlgoliaVersion[1] > 20
              ) {
                params.additionalUA = 'autocomplete.js ' + version;
              }
              detailsIndex.search(source(first), detailsParams, function (error2, content2) {
                if (error2) {
                  _.error(error2.message);
                  return;
                }
                var suggestions = [];
                if (options.includeAll) {
                  var label = options.allTitle || 'All departments';
                  suggestions.push(
                    _.mixin(
                      { facet: { value: label, count: content2.nbHits } },
                      _.cloneDeep(first),
                    ),
                  );
                }
                _.each(content2.facets, function (values, facet) {
                  _.each(values, function (count, value) {
                    suggestions.push(
                      _.mixin(
                        { facet: { facet: facet, value: value, count: count } },
                        _.cloneDeep(first),
                      ),
                    );
                  });
                });
                for (var i = 1; i < content.hits.length; ++i) {
                  suggestions.push(content.hits[i]);
                }
                cb(suggestions, content);
              });
              return;
            }
            cb([]);
          });
        }
      };
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      Object.defineProperty(exports, '__esModule', { value: true });
      var prefix = 'algolia-docsearch';
      var suggestionPrefix = prefix + '-suggestion';
      var footerPrefix = prefix + '-footer';
      var templates = {
        suggestion:
          '\n  <a class="' +
          suggestionPrefix +
          '\n    {{#isCategoryHeader}}' +
          suggestionPrefix +
          '__main{{/isCategoryHeader}}\n    {{#isSubCategoryHeader}}' +
          suggestionPrefix +
          '__secondary{{/isSubCategoryHeader}}\n    "\n    aria-label="Link to the result"\n    href="{{{url}}}"\n    >\n    <div class="' +
          suggestionPrefix +
          '--category-header">\n        <span class="' +
          suggestionPrefix +
          '--category-header-lvl0">{{{category}}}</span>\n    </div>\n    <div class="' +
          suggestionPrefix +
          '--wrapper">\n      <div class="' +
          suggestionPrefix +
          '--subcategory-column">\n        <span class="' +
          suggestionPrefix +
          '--subcategory-column-text">{{{subcategory}}}</span>\n      </div>\n      {{#isTextOrSubcategoryNonEmpty}}\n      <div class="' +
          suggestionPrefix +
          '--content">\n        <div class="' +
          suggestionPrefix +
          '--subcategory-inline">{{{subcategory}}}</div>\n        <div class="' +
          suggestionPrefix +
          '--title">{{{title}}}</div>\n        {{#text}}<div class="' +
          suggestionPrefix +
          '--text">{{{text}}}</div>{{/text}}\n      </div>\n      {{/isTextOrSubcategoryNonEmpty}}\n    </div>\n  </a>\n  ',
        suggestionSimple:
          '\n  <div class="' +
          suggestionPrefix +
          '\n    {{#isCategoryHeader}}' +
          suggestionPrefix +
          '__main{{/isCategoryHeader}}\n    {{#isSubCategoryHeader}}' +
          suggestionPrefix +
          '__secondary{{/isSubCategoryHeader}}\n    suggestion-layout-simple\n  ">\n    <div class="' +
          suggestionPrefix +
          '--category-header">\n        {{^isLvl0}}\n        <span class="' +
          suggestionPrefix +
          '--category-header-lvl0 ' +
          suggestionPrefix +
          '--category-header-item">{{{category}}}</span>\n          {{^isLvl1}}\n          {{^isLvl1EmptyOrDuplicate}}\n          <span class="' +
          suggestionPrefix +
          '--category-header-lvl1 ' +
          suggestionPrefix +
          '--category-header-item">\n              {{{subcategory}}}\n          </span>\n          {{/isLvl1EmptyOrDuplicate}}\n          {{/isLvl1}}\n        {{/isLvl0}}\n        <div class="' +
          suggestionPrefix +
          '--title ' +
          suggestionPrefix +
          '--category-header-item">\n            {{#isLvl2}}\n                {{{title}}}\n            {{/isLvl2}}\n            {{#isLvl1}}\n                {{{subcategory}}}\n            {{/isLvl1}}\n            {{#isLvl0}}\n                {{{category}}}\n            {{/isLvl0}}\n        </div>\n    </div>\n    <div class="' +
          suggestionPrefix +
          '--wrapper">\n      {{#text}}\n      <div class="' +
          suggestionPrefix +
          '--content">\n        <div class="' +
          suggestionPrefix +
          '--text">{{{text}}}</div>\n      </div>\n      {{/text}}\n    </div>\n  </div>\n  ',
        footer:
          '\n    <div class="' +
          footerPrefix +
          '">\n      Search by <a class="' +
          footerPrefix +
          '--logo" href="https://www.algolia.com/docsearch">Algolia</a>\n    </div>\n  ',
        empty:
          '\n  <div class="' +
          suggestionPrefix +
          '">\n    <div class="' +
          suggestionPrefix +
          '--wrapper">\n        <div class="' +
          suggestionPrefix +
          '--content ' +
          suggestionPrefix +
          '--no-results">\n            <div class="' +
          suggestionPrefix +
          '--title">\n                <div class="' +
          suggestionPrefix +
          '--text">\n                    No results found for query <b>"{{query}}"</b>\n                </div>\n            </div>\n        </div>\n    </div>\n  </div>\n  ',
        searchBox:
          '\n  <form novalidate="novalidate" onsubmit="return false;" class="searchbox">\n    <div role="search" class="searchbox__wrapper">\n      <input id="docsearch" type="search" name="search" placeholder="Search the docs" autocomplete="off" required="required" class="searchbox__input"/>\n      <button type="submit" title="Submit your search query." class="searchbox__submit" >\n        <svg width=12 height=12 role="img" aria-label="Search">\n          <use xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="#sbx-icon-search-13"></use>\n        </svg>\n      </button>\n      <button type="reset" title="Clear the search query." class="searchbox__reset hide">\n        <svg width=12 height=12 role="img" aria-label="Reset">\n          <use xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="#sbx-icon-clear-3"></use>\n        </svg>\n      </button>\n    </div>\n</form>\n\n<div class="svg-icons" style="height: 0; width: 0; position: absolute; visibility: hidden">\n  <svg xmlns="http://www.w3.org/2000/svg">\n    <symbol id="sbx-icon-clear-3" viewBox="0 0 40 40"><path d="M16.228 20L1.886 5.657 0 3.772 3.772 0l1.885 1.886L20 16.228 34.343 1.886 36.228 0 40 3.772l-1.886 1.885L23.772 20l14.342 14.343L40 36.228 36.228 40l-1.885-1.886L20 23.772 5.657 38.114 3.772 40 0 36.228l1.886-1.885L16.228 20z" fill-rule="evenodd"></symbol>\n    <symbol id="sbx-icon-search-13" viewBox="0 0 40 40"><path d="M26.806 29.012a16.312 16.312 0 0 1-10.427 3.746C7.332 32.758 0 25.425 0 16.378 0 7.334 7.333 0 16.38 0c9.045 0 16.378 7.333 16.378 16.38 0 3.96-1.406 7.593-3.746 10.426L39.547 37.34c.607.608.61 1.59-.004 2.203a1.56 1.56 0 0 1-2.202.004L26.807 29.012zm-10.427.627c7.322 0 13.26-5.938 13.26-13.26 0-7.324-5.938-13.26-13.26-13.26-7.324 0-13.26 5.936-13.26 13.26 0 7.322 5.936 13.26 13.26 13.26z" fill-rule="evenodd"></symbol>\n  </svg>\n</div>\n  ',
      };
      exports.default = templates;
    },
    function (module, exports, __webpack_require__) {
      'use strict';
      Object.defineProperty(exports, '__esModule', { value: true });
      var _typeof =
        typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'
          ? function (obj) {
              return typeof obj;
            }
          : function (obj) {
              return obj &&
                typeof Symbol === 'function' &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? 'symbol'
                : typeof obj;
            };
      var _zepto = __webpack_require__(20);
      var _zepto2 = _interopRequireDefault(_zepto);
      function _interopRequireDefault(obj) {
        return obj && obj.__esModule ? obj : { default: obj };
      }
      var utils = {
        mergeKeyWithParent: function mergeKeyWithParent(object, property) {
          if (object[property] === undefined) {
            return object;
          }
          if (_typeof(object[property]) !== 'object') {
            return object;
          }
          var newObject = _zepto2.default.extend({}, object, object[property]);
          delete newObject[property];
          return newObject;
        },
        groupBy: function groupBy(collection, property) {
          var newCollection = {};
          _zepto2.default.each(collection, function (index, item) {
            if (item[property] === undefined) {
              throw new Error('[groupBy]: Object has no key ' + property);
            }
            var key = item[property];
            if (typeof key === 'string') {
              key = key.toLowerCase();
            }
            if (!Object.prototype.hasOwnProperty.call(newCollection, key)) {
              newCollection[key] = [];
            }
            newCollection[key].push(item);
          });
          return newCollection;
        },
        values: function values(object) {
          return Object.keys(object).map(function (key) {
            return object[key];
          });
        },
        flatten: function flatten(array) {
          var results = [];
          array.forEach(function (value) {
            if (!Array.isArray(value)) {
              results.push(value);
              return;
            }
            value.forEach(function (subvalue) {
              results.push(subvalue);
            });
          });
          return results;
        },
        flattenAndFlagFirst: function flattenAndFlagFirst(object, flag) {
          var values = this.values(object).map(function (collection) {
            return collection.map(function (item, index) {
              item[flag] = index === 0;
              return item;
            });
          });
          return this.flatten(values);
        },
        compact: function compact(array) {
          var results = [];
          array.forEach(function (value) {
            if (!value) {
              return;
            }
            results.push(value);
          });
          return results;
        },
        getHighlightedValue: function getHighlightedValue(object, property) {
          if (
            object._highlightResult &&
            object._highlightResult.hierarchy_camel &&
            object._highlightResult.hierarchy_camel[property] &&
            object._highlightResult.hierarchy_camel[property].matchLevel &&
            object._highlightResult.hierarchy_camel[property].matchLevel !== 'none' &&
            object._highlightResult.hierarchy_camel[property].value
          ) {
            return object._highlightResult.hierarchy_camel[property].value;
          }
          if (
            object._highlightResult &&
            object._highlightResult &&
            object._highlightResult[property] &&
            object._highlightResult[property].value
          ) {
            return object._highlightResult[property].value;
          }
          return object[property];
        },
        getSnippetedValue: function getSnippetedValue(object, property) {
          if (
            !object._snippetResult ||
            !object._snippetResult[property] ||
            !object._snippetResult[property].value
          ) {
            return object[property];
          }
          var snippet = object._snippetResult[property].value;
          if (snippet[0] !== snippet[0].toUpperCase()) {
            snippet = '鈥�' + snippet;
          }
          if (['.', '!', '?'].indexOf(snippet[snippet.length - 1]) === -1) {
            snippet = snippet + '鈥�';
          }
          return snippet;
        },
        deepClone: function deepClone(object) {
          return JSON.parse(JSON.stringify(object));
        },
      };
      exports.default = utils;
    },
  ]);
});