up n_m

node_modules/@algolia/autocomplete-core/dist/esm/checkOptions.d.ts

@@ -0,0 +1,2 @@
+import { AutocompleteOptions, BaseItem } from './types';
+export declare function checkOptions<TItem extends BaseItem>(options: AutocompleteOptions<TItem>): void;

node_modules/@algolia/autocomplete-core/dist/esm/checkOptions.js

@@ -0,0 +1,4 @@
+import { warn } from '@algolia/autocomplete-shared';
+export function checkOptions(options) {
+  process.env.NODE_ENV !== 'production' ? warn(!options.debug, 'The `debug` option is meant for development debugging and should not be used in production.') : void 0;
+}

node_modules/@algolia/autocomplete-core/dist/esm/createAutocomplete.d.ts

@@ -0,0 +1,8 @@
+import { AutocompleteApi, AutocompleteOptions as AutocompleteCoreOptions, BaseItem } from './types';
+export interface AutocompleteOptionsWithMetadata<TItem extends BaseItem> extends AutocompleteCoreOptions<TItem> {
+    /**
+     * @internal
+     */
+    __autocomplete_metadata?: Record<string, unknown>;
+}
+export declare function createAutocomplete<TItem extends BaseItem, TEvent = Event, TMouseEvent = MouseEvent, TKeyboardEvent = KeyboardEvent>(options: AutocompleteOptionsWithMetadata<TItem>): AutocompleteApi<TItem, TEvent, TMouseEvent, TKeyboardEvent>;

node_modules/@algolia/autocomplete-core/dist/esm/createAutocomplete.js

@@ -0,0 +1,92 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { createAlgoliaInsightsPlugin } from '@algolia/autocomplete-plugin-algolia-insights';
+import { checkOptions } from './checkOptions';
+import { createStore } from './createStore';
+import { getAutocompleteSetters } from './getAutocompleteSetters';
+import { getDefaultProps } from './getDefaultProps';
+import { getPropGetters } from './getPropGetters';
+import { getMetadata, injectMetadata } from './metadata';
+import { onInput } from './onInput';
+import { stateReducer } from './stateReducer';
+export function createAutocomplete(options) {
+  checkOptions(options);
+  var subscribers = [];
+  var props = getDefaultProps(options, subscribers);
+  var store = createStore(stateReducer, props, onStoreStateChange);
+  var setters = getAutocompleteSetters({
+    store: store
+  });
+  var propGetters = getPropGetters(_objectSpread({
+    props: props,
+    refresh: refresh,
+    store: store,
+    navigator: props.navigator
+  }, setters));
+  function onStoreStateChange(_ref) {
+    var prevState = _ref.prevState,
+      state = _ref.state;
+    props.onStateChange(_objectSpread({
+      prevState: prevState,
+      state: state,
+      refresh: refresh,
+      navigator: props.navigator
+    }, setters));
+  }
+  function refresh() {
+    return onInput(_objectSpread({
+      event: new Event('input'),
+      nextState: {
+        isOpen: store.getState().isOpen
+      },
+      props: props,
+      navigator: props.navigator,
+      query: store.getState().query,
+      refresh: refresh,
+      store: store
+    }, setters));
+  }
+  if (options.insights && !props.plugins.some(function (plugin) {
+    return plugin.name === 'aa.algoliaInsightsPlugin';
+  })) {
+    var insightsParams = typeof options.insights === 'boolean' ? {} : options.insights;
+    props.plugins.push(createAlgoliaInsightsPlugin(insightsParams));
+  }
+  props.plugins.forEach(function (plugin) {
+    var _plugin$subscribe;
+    return (_plugin$subscribe = plugin.subscribe) === null || _plugin$subscribe === void 0 ? void 0 : _plugin$subscribe.call(plugin, _objectSpread(_objectSpread({}, setters), {}, {
+      navigator: props.navigator,
+      refresh: refresh,
+      onSelect: function onSelect(fn) {
+        subscribers.push({
+          onSelect: fn
+        });
+      },
+      onActive: function onActive(fn) {
+        subscribers.push({
+          onActive: fn
+        });
+      },
+      onResolve: function onResolve(fn) {
+        subscribers.push({
+          onResolve: fn
+        });
+      }
+    }));
+  });
+  injectMetadata({
+    metadata: getMetadata({
+      plugins: props.plugins,
+      options: options
+    }),
+    environment: props.environment
+  });
+  return _objectSpread(_objectSpread({
+    refresh: refresh,
+    navigator: props.navigator
+  }, propGetters), setters);
+}

node_modules/@algolia/autocomplete-core/dist/esm/createStore.d.ts

@@ -0,0 +1,7 @@
+import { AutocompleteState, AutocompleteStore, BaseItem, InternalAutocompleteOptions, Reducer } from './types';
+declare type OnStoreStateChange<TItem extends BaseItem> = ({ prevState, state, }: {
+    prevState: AutocompleteState<TItem>;
+    state: AutocompleteState<TItem>;
+}) => void;
+export declare function createStore<TItem extends BaseItem>(reducer: Reducer, props: InternalAutocompleteOptions<TItem>, onStoreStateChange: OnStoreStateChange<TItem>): AutocompleteStore<TItem>;
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/createStore.js

@@ -0,0 +1,28 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { createCancelablePromiseList } from './utils';
+export function createStore(reducer, props, onStoreStateChange) {
+  var state = props.initialState;
+  return {
+    getState: function getState() {
+      return state;
+    },
+    dispatch: function dispatch(action, payload) {
+      var prevState = _objectSpread({}, state);
+      state = reducer(state, {
+        type: action,
+        props: props,
+        payload: payload
+      });
+      onStoreStateChange({
+        state: state,
+        prevState: prevState
+      });
+    },
+    pendingRequests: createCancelablePromiseList()
+  };
+}

node_modules/@algolia/autocomplete-core/dist/esm/getAutocompleteSetters.d.ts

@@ -0,0 +1,13 @@
+import { AutocompleteCollection, AutocompleteStore, BaseItem } from './types';
+interface GetAutocompleteSettersOptions<TItem extends BaseItem> {
+    store: AutocompleteStore<TItem>;
+}
+export declare function getAutocompleteSetters<TItem extends BaseItem>({ store, }: GetAutocompleteSettersOptions<TItem>): {
+    setActiveItemId: import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteSetters").StateUpdater<number | null>;
+    setQuery: import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteSetters").StateUpdater<string>;
+    setCollections: import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteSetters").StateUpdater<(AutocompleteCollection<TItem> | import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteCollection").AutocompleteCollectionItemsArray<TItem>)[]>;
+    setIsOpen: import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteSetters").StateUpdater<boolean>;
+    setStatus: import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteSetters").StateUpdater<"idle" | "loading" | "stalled" | "error">;
+    setContext: import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteSetters").StateUpdater<import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteContext").AutocompleteContext>;
+};
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/getAutocompleteSetters.js

@@ -0,0 +1,48 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { flatten } from '@algolia/autocomplete-shared';
+export function getAutocompleteSetters(_ref) {
+  var store = _ref.store;
+  var setActiveItemId = function setActiveItemId(value) {
+    store.dispatch('setActiveItemId', value);
+  };
+  var setQuery = function setQuery(value) {
+    store.dispatch('setQuery', value);
+  };
+  var setCollections = function setCollections(rawValue) {
+    var baseItemId = 0;
+    var value = rawValue.map(function (collection) {
+      return _objectSpread(_objectSpread({}, collection), {}, {
+        // We flatten the stored items to support calling `getAlgoliaResults`
+        // from the source itself.
+        items: flatten(collection.items).map(function (item) {
+          return _objectSpread(_objectSpread({}, item), {}, {
+            __autocomplete_id: baseItemId++
+          });
+        })
+      });
+    });
+    store.dispatch('setCollections', value);
+  };
+  var setIsOpen = function setIsOpen(value) {
+    store.dispatch('setIsOpen', value);
+  };
+  var setStatus = function setStatus(value) {
+    store.dispatch('setStatus', value);
+  };
+  var setContext = function setContext(value) {
+    store.dispatch('setContext', value);
+  };
+  return {
+    setActiveItemId: setActiveItemId,
+    setQuery: setQuery,
+    setCollections: setCollections,
+    setIsOpen: setIsOpen,
+    setStatus: setStatus,
+    setContext: setContext
+  };
+}

node_modules/@algolia/autocomplete-core/dist/esm/getCompletion.d.ts

@@ -0,0 +1,6 @@
+import { AutocompleteState, BaseItem } from './types';
+interface GetCompletionProps<TItem extends BaseItem> {
+    state: AutocompleteState<TItem>;
+}
+export declare function getCompletion<TItem extends BaseItem>({ state, }: GetCompletionProps<TItem>): string | null;
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/getCompletion.js

@@ -0,0 +1,9 @@
+import { getActiveItem } from './utils';
+export function getCompletion(_ref) {
+  var _getActiveItem;
+  var state = _ref.state;
+  if (state.isOpen === false || state.activeItemId === null) {
+    return null;
+  }
+  return ((_getActiveItem = getActiveItem(state)) === null || _getActiveItem === void 0 ? void 0 : _getActiveItem.itemInputValue) || null;
+}

node_modules/@algolia/autocomplete-core/dist/esm/getDefaultProps.d.ts

@@ -0,0 +1,2 @@
+import { AutocompleteOptions, AutocompleteSubscribers, BaseItem, InternalAutocompleteOptions } from './types';
+export declare function getDefaultProps<TItem extends BaseItem>(props: AutocompleteOptions<TItem>, pluginSubscribers: AutocompleteSubscribers<TItem>): InternalAutocompleteOptions<TItem>;

node_modules/@algolia/autocomplete-core/dist/esm/getDefaultProps.js

@@ -0,0 +1,128 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { getItemsCount, generateAutocompleteId, flatten } from '@algolia/autocomplete-shared';
+import { getNormalizedSources } from './utils';
+export function getDefaultProps(props, pluginSubscribers) {
+  var _props$id;
+  /* eslint-disable no-restricted-globals */
+  var environment = typeof window !== 'undefined' ? window : {};
+  /* eslint-enable no-restricted-globals */
+  var plugins = props.plugins || [];
+  return _objectSpread(_objectSpread({
+    debug: false,
+    openOnFocus: false,
+    placeholder: '',
+    autoFocus: false,
+    defaultActiveItemId: null,
+    stallThreshold: 300,
+    insights: false,
+    environment: environment,
+    shouldPanelOpen: function shouldPanelOpen(_ref) {
+      var state = _ref.state;
+      return getItemsCount(state) > 0;
+    },
+    reshape: function reshape(_ref2) {
+      var sources = _ref2.sources;
+      return sources;
+    }
+  }, props), {}, {
+    // Since `generateAutocompleteId` triggers a side effect (it increments
+    // an internal counter), we don't want to execute it if unnecessary.
+    id: (_props$id = props.id) !== null && _props$id !== void 0 ? _props$id : generateAutocompleteId(),
+    plugins: plugins,
+    // The following props need to be deeply defaulted.
+    initialState: _objectSpread({
+      activeItemId: null,
+      query: '',
+      completion: null,
+      collections: [],
+      isOpen: false,
+      status: 'idle',
+      context: {}
+    }, props.initialState),
+    onStateChange: function onStateChange(params) {
+      var _props$onStateChange;
+      (_props$onStateChange = props.onStateChange) === null || _props$onStateChange === void 0 ? void 0 : _props$onStateChange.call(props, params);
+      plugins.forEach(function (x) {
+        var _x$onStateChange;
+        return (_x$onStateChange = x.onStateChange) === null || _x$onStateChange === void 0 ? void 0 : _x$onStateChange.call(x, params);
+      });
+    },
+    onSubmit: function onSubmit(params) {
+      var _props$onSubmit;
+      (_props$onSubmit = props.onSubmit) === null || _props$onSubmit === void 0 ? void 0 : _props$onSubmit.call(props, params);
+      plugins.forEach(function (x) {
+        var _x$onSubmit;
+        return (_x$onSubmit = x.onSubmit) === null || _x$onSubmit === void 0 ? void 0 : _x$onSubmit.call(x, params);
+      });
+    },
+    onReset: function onReset(params) {
+      var _props$onReset;
+      (_props$onReset = props.onReset) === null || _props$onReset === void 0 ? void 0 : _props$onReset.call(props, params);
+      plugins.forEach(function (x) {
+        var _x$onReset;
+        return (_x$onReset = x.onReset) === null || _x$onReset === void 0 ? void 0 : _x$onReset.call(x, params);
+      });
+    },
+    getSources: function getSources(params) {
+      return Promise.all([].concat(_toConsumableArray(plugins.map(function (plugin) {
+        return plugin.getSources;
+      })), [props.getSources]).filter(Boolean).map(function (getSources) {
+        return getNormalizedSources(getSources, params);
+      })).then(function (nested) {
+        return flatten(nested);
+      }).then(function (sources) {
+        return sources.map(function (source) {
+          return _objectSpread(_objectSpread({}, source), {}, {
+            onSelect: function onSelect(params) {
+              source.onSelect(params);
+              pluginSubscribers.forEach(function (x) {
+                var _x$onSelect;
+                return (_x$onSelect = x.onSelect) === null || _x$onSelect === void 0 ? void 0 : _x$onSelect.call(x, params);
+              });
+            },
+            onActive: function onActive(params) {
+              source.onActive(params);
+              pluginSubscribers.forEach(function (x) {
+                var _x$onActive;
+                return (_x$onActive = x.onActive) === null || _x$onActive === void 0 ? void 0 : _x$onActive.call(x, params);
+              });
+            },
+            onResolve: function onResolve(params) {
+              source.onResolve(params);
+              pluginSubscribers.forEach(function (x) {
+                var _x$onResolve;
+                return (_x$onResolve = x.onResolve) === null || _x$onResolve === void 0 ? void 0 : _x$onResolve.call(x, params);
+              });
+            }
+          });
+        });
+      });
+    },
+    navigator: _objectSpread({
+      navigate: function navigate(_ref3) {
+        var itemUrl = _ref3.itemUrl;
+        environment.location.assign(itemUrl);
+      },
+      navigateNewTab: function navigateNewTab(_ref4) {
+        var itemUrl = _ref4.itemUrl;
+        var windowReference = environment.open(itemUrl, '_blank', 'noopener');
+        windowReference === null || windowReference === void 0 ? void 0 : windowReference.focus();
+      },
+      navigateNewWindow: function navigateNewWindow(_ref5) {
+        var itemUrl = _ref5.itemUrl;
+        environment.open(itemUrl, '_blank', 'noopener');
+      }
+    }, props.navigator)
+  });
+}

node_modules/@algolia/autocomplete-core/dist/esm/getPropGetters.d.ts

@@ -0,0 +1,16 @@
+import { AutocompleteScopeApi, AutocompleteStore, BaseItem, GetEnvironmentProps, GetFormProps, GetInputProps, GetItemProps, GetLabelProps, GetListProps, GetPanelProps, GetRootProps, InternalAutocompleteOptions } from './types';
+interface GetPropGettersOptions<TItem extends BaseItem> extends AutocompleteScopeApi<TItem> {
+    store: AutocompleteStore<TItem>;
+    props: InternalAutocompleteOptions<TItem>;
+}
+export declare function getPropGetters<TItem extends BaseItem, TEvent, TMouseEvent, TKeyboardEvent>({ props, refresh, store, ...setters }: GetPropGettersOptions<TItem>): {
+    getEnvironmentProps: GetEnvironmentProps;
+    getRootProps: GetRootProps;
+    getFormProps: GetFormProps<TEvent>;
+    getLabelProps: GetLabelProps;
+    getInputProps: GetInputProps<TEvent, TMouseEvent, TKeyboardEvent>;
+    getPanelProps: GetPanelProps<TMouseEvent>;
+    getListProps: GetListProps;
+    getItemProps: GetItemProps<any, TMouseEvent>;
+};
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/getPropGetters.js

@@ -0,0 +1,320 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["props", "refresh", "store"],
+  _excluded2 = ["inputElement", "formElement", "panelElement"],
+  _excluded3 = ["inputElement"],
+  _excluded4 = ["inputElement", "maxLength"],
+  _excluded5 = ["sourceIndex"],
+  _excluded6 = ["sourceIndex"],
+  _excluded7 = ["item", "source", "sourceIndex"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import { noop } from '@algolia/autocomplete-shared';
+import { onInput } from './onInput';
+import { onKeyDown as _onKeyDown } from './onKeyDown';
+import { getActiveItem, isOrContainsNode, isSamsung } from './utils';
+export function getPropGetters(_ref) {
+  var props = _ref.props,
+    refresh = _ref.refresh,
+    store = _ref.store,
+    setters = _objectWithoutProperties(_ref, _excluded);
+  var getEnvironmentProps = function getEnvironmentProps(providedProps) {
+    var inputElement = providedProps.inputElement,
+      formElement = providedProps.formElement,
+      panelElement = providedProps.panelElement,
+      rest = _objectWithoutProperties(providedProps, _excluded2);
+    function onMouseDownOrTouchStart(event) {
+      // The `onTouchStart`/`onMouseDown` events shouldn't trigger the `blur`
+      // handler when it's not an interaction with Autocomplete.
+      // We detect it with the following heuristics:
+      // - the panel is closed AND there are no pending requests
+      //   (no interaction with the autocomplete, no future state updates)
+      // - OR the touched target is the input element (should open the panel)
+      var isAutocompleteInteraction = store.getState().isOpen || !store.pendingRequests.isEmpty();
+      if (!isAutocompleteInteraction || event.target === inputElement) {
+        return;
+      }
+
+      // @TODO: support cases where there are multiple Autocomplete instances.
+      // Right now, a second instance makes this computation return false.
+      var isTargetWithinAutocomplete = [formElement, panelElement].some(function (contextNode) {
+        return isOrContainsNode(contextNode, event.target);
+      });
+      if (isTargetWithinAutocomplete === false) {
+        store.dispatch('blur', null);
+
+        // If requests are still pending when the user closes the panel, they
+        // could reopen the panel once they resolve.
+        // We want to prevent any subsequent query from reopening the panel
+        // because it would result in an unsolicited UI behavior.
+        if (!props.debug) {
+          store.pendingRequests.cancelAll();
+        }
+      }
+    }
+    return _objectSpread({
+      // We do not rely on the native `blur` event of the input to close the
+      // panel, but rather on a custom `touchstart`/`mousedown` event outside
+      // of the autocomplete elements.
+      // This ensures we don't mistakenly interpret interactions within the
+      // autocomplete (but outside of the input) as a signal to close the panel.
+      // For example, clicking reset button causes an input blur, but if
+      // `openOnFocus=true`, it shouldn't close the panel.
+      // On touch devices, scrolling results (`touchmove`) causes an input blur
+      // but shouldn't close the panel.
+      onTouchStart: onMouseDownOrTouchStart,
+      onMouseDown: onMouseDownOrTouchStart,
+      // When scrolling on touch devices (mobiles, tablets, etc.), we want to
+      // mimic the native platform behavior where the input is blurred to
+      // hide the virtual keyboard. This gives more vertical space to
+      // discover all the suggestions showing up in the panel.
+      onTouchMove: function onTouchMove(event) {
+        if (store.getState().isOpen === false || inputElement !== props.environment.document.activeElement || event.target === inputElement) {
+          return;
+        }
+        inputElement.blur();
+      }
+    }, rest);
+  };
+  var getRootProps = function getRootProps(rest) {
+    return _objectSpread({
+      role: 'combobox',
+      'aria-expanded': store.getState().isOpen,
+      'aria-haspopup': 'listbox',
+      'aria-owns': store.getState().isOpen ? "".concat(props.id, "-list") : undefined,
+      'aria-labelledby': "".concat(props.id, "-label")
+    }, rest);
+  };
+  var getFormProps = function getFormProps(providedProps) {
+    var inputElement = providedProps.inputElement,
+      rest = _objectWithoutProperties(providedProps, _excluded3);
+    return _objectSpread({
+      action: '',
+      noValidate: true,
+      role: 'search',
+      onSubmit: function onSubmit(event) {
+        var _providedProps$inputE;
+        event.preventDefault();
+        props.onSubmit(_objectSpread({
+          event: event,
+          refresh: refresh,
+          state: store.getState()
+        }, setters));
+        store.dispatch('submit', null);
+        (_providedProps$inputE = providedProps.inputElement) === null || _providedProps$inputE === void 0 ? void 0 : _providedProps$inputE.blur();
+      },
+      onReset: function onReset(event) {
+        var _providedProps$inputE2;
+        event.preventDefault();
+        props.onReset(_objectSpread({
+          event: event,
+          refresh: refresh,
+          state: store.getState()
+        }, setters));
+        store.dispatch('reset', null);
+        (_providedProps$inputE2 = providedProps.inputElement) === null || _providedProps$inputE2 === void 0 ? void 0 : _providedProps$inputE2.focus();
+      }
+    }, rest);
+  };
+  var getInputProps = function getInputProps(providedProps) {
+    var _props$environment$na;
+    function onFocus(event) {
+      // We want to trigger a query when `openOnFocus` is true
+      // because the panel should open with the current query.
+      if (props.openOnFocus || Boolean(store.getState().query)) {
+        onInput(_objectSpread({
+          event: event,
+          props: props,
+          query: store.getState().completion || store.getState().query,
+          refresh: refresh,
+          store: store
+        }, setters));
+      }
+      store.dispatch('focus', null);
+    }
+    var _ref2 = providedProps || {},
+      inputElement = _ref2.inputElement,
+      _ref2$maxLength = _ref2.maxLength,
+      maxLength = _ref2$maxLength === void 0 ? 512 : _ref2$maxLength,
+      rest = _objectWithoutProperties(_ref2, _excluded4);
+    var activeItem = getActiveItem(store.getState());
+    var userAgent = ((_props$environment$na = props.environment.navigator) === null || _props$environment$na === void 0 ? void 0 : _props$environment$na.userAgent) || '';
+    var shouldFallbackKeyHint = isSamsung(userAgent);
+    var enterKeyHint = activeItem !== null && activeItem !== void 0 && activeItem.itemUrl && !shouldFallbackKeyHint ? 'go' : 'search';
+    return _objectSpread({
+      'aria-autocomplete': 'both',
+      'aria-activedescendant': store.getState().isOpen && store.getState().activeItemId !== null ? "".concat(props.id, "-item-").concat(store.getState().activeItemId) : undefined,
+      'aria-controls': store.getState().isOpen ? "".concat(props.id, "-list") : undefined,
+      'aria-labelledby': "".concat(props.id, "-label"),
+      value: store.getState().completion || store.getState().query,
+      id: "".concat(props.id, "-input"),
+      autoComplete: 'off',
+      autoCorrect: 'off',
+      autoCapitalize: 'off',
+      enterKeyHint: enterKeyHint,
+      spellCheck: 'false',
+      autoFocus: props.autoFocus,
+      placeholder: props.placeholder,
+      maxLength: maxLength,
+      type: 'search',
+      onChange: function onChange(event) {
+        onInput(_objectSpread({
+          event: event,
+          props: props,
+          query: event.currentTarget.value.slice(0, maxLength),
+          refresh: refresh,
+          store: store
+        }, setters));
+      },
+      onKeyDown: function onKeyDown(event) {
+        _onKeyDown(_objectSpread({
+          event: event,
+          props: props,
+          refresh: refresh,
+          store: store
+        }, setters));
+      },
+      onFocus: onFocus,
+      // We don't rely on the `blur` event.
+      // See explanation in `onTouchStart`/`onMouseDown`.
+      // @MAJOR See if we need to keep this handler.
+      onBlur: noop,
+      onClick: function onClick(event) {
+        // When the panel is closed and you click on the input while
+        // the input is focused, the `onFocus` event is not triggered
+        // (default browser behavior).
+        // In an autocomplete context, it makes sense to open the panel in this
+        // case.
+        // We mimic this event by catching the `onClick` event which
+        // triggers the `onFocus` for the panel to open.
+        if (providedProps.inputElement === props.environment.document.activeElement && !store.getState().isOpen) {
+          onFocus(event);
+        }
+      }
+    }, rest);
+  };
+  var getAutocompleteId = function getAutocompleteId(instanceId, sourceId) {
+    return typeof sourceId !== 'undefined' ? "".concat(instanceId, "-").concat(sourceId) : instanceId;
+  };
+  var getLabelProps = function getLabelProps(providedProps) {
+    var _ref3 = providedProps || {},
+      sourceIndex = _ref3.sourceIndex,
+      rest = _objectWithoutProperties(_ref3, _excluded5);
+    return _objectSpread({
+      htmlFor: "".concat(getAutocompleteId(props.id, sourceIndex), "-input"),
+      id: "".concat(getAutocompleteId(props.id, sourceIndex), "-label")
+    }, rest);
+  };
+  var getListProps = function getListProps(providedProps) {
+    var _ref4 = providedProps || {},
+      sourceIndex = _ref4.sourceIndex,
+      rest = _objectWithoutProperties(_ref4, _excluded6);
+    return _objectSpread({
+      role: 'listbox',
+      'aria-labelledby': "".concat(getAutocompleteId(props.id, sourceIndex), "-label"),
+      id: "".concat(getAutocompleteId(props.id, sourceIndex), "-list")
+    }, rest);
+  };
+  var getPanelProps = function getPanelProps(rest) {
+    return _objectSpread({
+      onMouseDown: function onMouseDown(event) {
+        // Prevents the `activeElement` from being changed to the panel so
+        // that the blur event is not triggered, otherwise it closes the
+        // panel.
+        event.preventDefault();
+      },
+      onMouseLeave: function onMouseLeave() {
+        store.dispatch('mouseleave', null);
+      }
+    }, rest);
+  };
+  var getItemProps = function getItemProps(providedProps) {
+    var item = providedProps.item,
+      source = providedProps.source,
+      sourceIndex = providedProps.sourceIndex,
+      rest = _objectWithoutProperties(providedProps, _excluded7);
+    return _objectSpread({
+      id: "".concat(getAutocompleteId(props.id, sourceIndex), "-item-").concat(item.__autocomplete_id),
+      role: 'option',
+      'aria-selected': store.getState().activeItemId === item.__autocomplete_id,
+      onMouseMove: function onMouseMove(event) {
+        if (item.__autocomplete_id === store.getState().activeItemId) {
+          return;
+        }
+        store.dispatch('mousemove', item.__autocomplete_id);
+        var activeItem = getActiveItem(store.getState());
+        if (store.getState().activeItemId !== null && activeItem) {
+          var _item = activeItem.item,
+            itemInputValue = activeItem.itemInputValue,
+            itemUrl = activeItem.itemUrl,
+            _source = activeItem.source;
+          _source.onActive(_objectSpread({
+            event: event,
+            item: _item,
+            itemInputValue: itemInputValue,
+            itemUrl: itemUrl,
+            refresh: refresh,
+            source: _source,
+            state: store.getState()
+          }, setters));
+        }
+      },
+      onMouseDown: function onMouseDown(event) {
+        // Prevents the `activeElement` from being changed to the item so it
+        // can remain with the current `activeElement`.
+        event.preventDefault();
+      },
+      onClick: function onClick(event) {
+        var itemInputValue = source.getItemInputValue({
+          item: item,
+          state: store.getState()
+        });
+        var itemUrl = source.getItemUrl({
+          item: item,
+          state: store.getState()
+        });
+
+        // If `getItemUrl` is provided, it means that the suggestion
+        // is a link, not plain text that aims at updating the query.
+        // We can therefore skip the state change because it will update
+        // the `activeItemId`, resulting in a UI flash, especially
+        // noticeable on mobile.
+        var runPreCommand = itemUrl ? Promise.resolve() : onInput(_objectSpread({
+          event: event,
+          nextState: {
+            isOpen: false
+          },
+          props: props,
+          query: itemInputValue,
+          refresh: refresh,
+          store: store
+        }, setters));
+        runPreCommand.then(function () {
+          source.onSelect(_objectSpread({
+            event: event,
+            item: item,
+            itemInputValue: itemInputValue,
+            itemUrl: itemUrl,
+            refresh: refresh,
+            source: source,
+            state: store.getState()
+          }, setters));
+        });
+      }
+    }, rest);
+  };
+  return {
+    getEnvironmentProps: getEnvironmentProps,
+    getRootProps: getRootProps,
+    getFormProps: getFormProps,
+    getLabelProps: getLabelProps,
+    getInputProps: getInputProps,
+    getPanelProps: getPanelProps,
+    getListProps: getListProps,
+    getItemProps: getItemProps
+  };
+}

node_modules/@algolia/autocomplete-core/dist/esm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './createAutocomplete';
+export * from './getDefaultProps';
+export * from './types';

node_modules/@algolia/autocomplete-core/dist/esm/index.js

@@ -0,0 +1,3 @@
+export * from './createAutocomplete';
+export * from './getDefaultProps';
+export * from './types';

node_modules/@algolia/autocomplete-core/dist/esm/metadata.d.ts

@@ -0,0 +1,33 @@
+import { UserAgent } from '@algolia/autocomplete-shared';
+import { AutocompleteEnvironment, AutocompleteOptionsWithMetadata, AutocompletePlugin, BaseItem } from '.';
+declare type AutocompleteMetadata = {
+    plugins: Array<{
+        name: string | undefined;
+        options: string[];
+    }>;
+    options: Record<string, string[]>;
+    ua: UserAgent[];
+};
+declare type GetMetadataParams<TItem extends BaseItem, TData = unknown> = {
+    plugins: Array<AutocompletePlugin<TItem, TData>>;
+    options: AutocompleteOptionsWithMetadata<TItem>;
+};
+export declare function getMetadata<TItem extends BaseItem, TData = unknown>({ plugins, options, }: GetMetadataParams<TItem, TData>): {
+    plugins: {
+        name: string | undefined;
+        options: string[];
+    }[];
+    options: {
+        'autocomplete-core': string[];
+    };
+    ua: {
+        segment: string;
+        version: string;
+    }[];
+};
+declare type InlineMetadataParams = {
+    metadata: AutocompleteMetadata;
+    environment: AutocompleteEnvironment;
+};
+export declare function injectMetadata({ metadata, environment, }: InlineMetadataParams): void;
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/metadata.js

@@ -0,0 +1,41 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { userAgents } from '@algolia/autocomplete-shared';
+export function getMetadata(_ref) {
+  var _, _options$__autocomple, _options$__autocomple2, _options$__autocomple3;
+  var plugins = _ref.plugins,
+    options = _ref.options;
+  var optionsKey = (_ = (((_options$__autocomple = options.__autocomplete_metadata) === null || _options$__autocomple === void 0 ? void 0 : _options$__autocomple.userAgents) || [])[0]) === null || _ === void 0 ? void 0 : _.segment;
+  var extraOptions = optionsKey ? _defineProperty({}, optionsKey, Object.keys(((_options$__autocomple2 = options.__autocomplete_metadata) === null || _options$__autocomple2 === void 0 ? void 0 : _options$__autocomple2.options) || {})) : {};
+  return {
+    plugins: plugins.map(function (plugin) {
+      return {
+        name: plugin.name,
+        options: Object.keys(plugin.__autocomplete_pluginOptions || [])
+      };
+    }),
+    options: _objectSpread({
+      'autocomplete-core': Object.keys(options)
+    }, extraOptions),
+    ua: userAgents.concat(((_options$__autocomple3 = options.__autocomplete_metadata) === null || _options$__autocomple3 === void 0 ? void 0 : _options$__autocomple3.userAgents) || [])
+  };
+}
+export function injectMetadata(_ref3) {
+  var _environment$navigato, _environment$navigato2;
+  var metadata = _ref3.metadata,
+    environment = _ref3.environment;
+  var isMetadataEnabled = (_environment$navigato = environment.navigator) === null || _environment$navigato === void 0 ? void 0 : (_environment$navigato2 = _environment$navigato.userAgent) === null || _environment$navigato2 === void 0 ? void 0 : _environment$navigato2.includes('Algolia Crawler');
+  if (isMetadataEnabled) {
+    var metadataContainer = environment.document.createElement('meta');
+    var headRef = environment.document.querySelector('head');
+    metadataContainer.name = 'algolia:metadata';
+    setTimeout(function () {
+      metadataContainer.content = JSON.stringify(metadata);
+      headRef.appendChild(metadataContainer);
+    }, 0);
+  }
+}

node_modules/@algolia/autocomplete-core/dist/esm/onInput.d.ts

@@ -0,0 +1,18 @@
+import { AutocompleteScopeApi, AutocompleteState, AutocompleteStore, BaseItem, InternalAutocompleteOptions } from './types';
+import { CancelablePromise } from './utils';
+interface OnInputParams<TItem extends BaseItem> extends AutocompleteScopeApi<TItem> {
+    event: any;
+    /**
+     * The next partial state to apply after the function is called.
+     *
+     * This is useful when we call `onInput` in a different scenario than an
+     * actual input. For example, we use `onInput` when we click on an item,
+     * but we want to close the panel in that case.
+     */
+    nextState?: Partial<AutocompleteState<TItem>>;
+    props: InternalAutocompleteOptions<TItem>;
+    query: string;
+    store: AutocompleteStore<TItem>;
+}
+export declare function onInput<TItem extends BaseItem>({ event, nextState, props, query, refresh, store, ...setters }: OnInputParams<TItem>): CancelablePromise<void>;
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/onInput.js

@@ -0,0 +1,125 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["event", "nextState", "props", "query", "refresh", "store"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import { reshape } from './reshape';
+import { preResolve, resolve, postResolve } from './resolve';
+import { cancelable, createConcurrentSafePromise, getActiveItem } from './utils';
+var lastStalledId = null;
+var runConcurrentSafePromise = createConcurrentSafePromise();
+export function onInput(_ref) {
+  var event = _ref.event,
+    _ref$nextState = _ref.nextState,
+    nextState = _ref$nextState === void 0 ? {} : _ref$nextState,
+    props = _ref.props,
+    query = _ref.query,
+    refresh = _ref.refresh,
+    store = _ref.store,
+    setters = _objectWithoutProperties(_ref, _excluded);
+  if (lastStalledId) {
+    props.environment.clearTimeout(lastStalledId);
+  }
+  var setCollections = setters.setCollections,
+    setIsOpen = setters.setIsOpen,
+    setQuery = setters.setQuery,
+    setActiveItemId = setters.setActiveItemId,
+    setStatus = setters.setStatus;
+  setQuery(query);
+  setActiveItemId(props.defaultActiveItemId);
+  if (!query && props.openOnFocus === false) {
+    var _nextState$isOpen;
+    var collections = store.getState().collections.map(function (collection) {
+      return _objectSpread(_objectSpread({}, collection), {}, {
+        items: []
+      });
+    });
+    setStatus('idle');
+    setCollections(collections);
+    setIsOpen((_nextState$isOpen = nextState.isOpen) !== null && _nextState$isOpen !== void 0 ? _nextState$isOpen : props.shouldPanelOpen({
+      state: store.getState()
+    }));
+
+    // We make sure to update the latest resolved value of the tracked
+    // promises to keep late resolving promises from "cancelling" the state
+    // updates performed in this code path.
+    // We chain with a void promise to respect `onInput`'s expected return type.
+    var _request = cancelable(runConcurrentSafePromise(collections).then(function () {
+      return Promise.resolve();
+    }));
+    return store.pendingRequests.add(_request);
+  }
+  setStatus('loading');
+  lastStalledId = props.environment.setTimeout(function () {
+    setStatus('stalled');
+  }, props.stallThreshold);
+
+  // We track the entire promise chain triggered by `onInput` before mutating
+  // the Autocomplete state to make sure that any state manipulation is based on
+  // fresh data regardless of when promises individually resolve.
+  // We don't track nested promises and only rely on the full chain resolution,
+  // meaning we should only ever manipulate the state once this concurrent-safe
+  // promise is resolved.
+  var request = cancelable(runConcurrentSafePromise(props.getSources(_objectSpread({
+    query: query,
+    refresh: refresh,
+    state: store.getState()
+  }, setters)).then(function (sources) {
+    return Promise.all(sources.map(function (source) {
+      return Promise.resolve(source.getItems(_objectSpread({
+        query: query,
+        refresh: refresh,
+        state: store.getState()
+      }, setters))).then(function (itemsOrDescription) {
+        return preResolve(itemsOrDescription, source.sourceId, store.getState());
+      });
+    })).then(resolve).then(function (responses) {
+      return postResolve(responses, sources, store);
+    }).then(function (collections) {
+      return reshape({
+        collections: collections,
+        props: props,
+        state: store.getState()
+      });
+    });
+  }))).then(function (collections) {
+    var _nextState$isOpen2;
+    // Parameters passed to `onInput` could be stale when the following code
+    // executes, because `onInput` calls may not resolve in order.
+    // If it becomes a problem we'll need to save the last passed parameters.
+    // See: https://codesandbox.io/s/agitated-cookies-y290z
+
+    setStatus('idle');
+    setCollections(collections);
+    var isPanelOpen = props.shouldPanelOpen({
+      state: store.getState()
+    });
+    setIsOpen((_nextState$isOpen2 = nextState.isOpen) !== null && _nextState$isOpen2 !== void 0 ? _nextState$isOpen2 : props.openOnFocus && !query && isPanelOpen || isPanelOpen);
+    var highlightedItem = getActiveItem(store.getState());
+    if (store.getState().activeItemId !== null && highlightedItem) {
+      var item = highlightedItem.item,
+        itemInputValue = highlightedItem.itemInputValue,
+        itemUrl = highlightedItem.itemUrl,
+        source = highlightedItem.source;
+      source.onActive(_objectSpread({
+        event: event,
+        item: item,
+        itemInputValue: itemInputValue,
+        itemUrl: itemUrl,
+        refresh: refresh,
+        source: source,
+        state: store.getState()
+      }, setters));
+    }
+  }).finally(function () {
+    setStatus('idle');
+    if (lastStalledId) {
+      props.environment.clearTimeout(lastStalledId);
+    }
+  });
+  return store.pendingRequests.add(request);
+}

node_modules/@algolia/autocomplete-core/dist/esm/onKeyDown.d.ts

@@ -0,0 +1,8 @@
+import { AutocompleteScopeApi, AutocompleteStore, BaseItem, InternalAutocompleteOptions } from './types';
+interface OnKeyDownOptions<TItem extends BaseItem> extends AutocompleteScopeApi<TItem> {
+    event: KeyboardEvent;
+    props: InternalAutocompleteOptions<TItem>;
+    store: AutocompleteStore<TItem>;
+}
+export declare function onKeyDown<TItem extends BaseItem>({ event, props, refresh, store, ...setters }: OnKeyDownOptions<TItem>): void;
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/onKeyDown.js

@@ -0,0 +1,195 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["event", "props", "refresh", "store"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import { onInput } from './onInput';
+import { getActiveItem } from './utils';
+export function onKeyDown(_ref) {
+  var event = _ref.event,
+    props = _ref.props,
+    refresh = _ref.refresh,
+    store = _ref.store,
+    setters = _objectWithoutProperties(_ref, _excluded);
+  if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {
+    // eslint-disable-next-line no-inner-declarations
+    var triggerScrollIntoView = function triggerScrollIntoView() {
+      var nodeItem = props.environment.document.getElementById("".concat(props.id, "-item-").concat(store.getState().activeItemId));
+      if (nodeItem) {
+        if (nodeItem.scrollIntoViewIfNeeded) {
+          nodeItem.scrollIntoViewIfNeeded(false);
+        } else {
+          nodeItem.scrollIntoView(false);
+        }
+      }
+    }; // eslint-disable-next-line no-inner-declarations
+    var triggerOnActive = function triggerOnActive() {
+      var highlightedItem = getActiveItem(store.getState());
+      if (store.getState().activeItemId !== null && highlightedItem) {
+        var item = highlightedItem.item,
+          itemInputValue = highlightedItem.itemInputValue,
+          itemUrl = highlightedItem.itemUrl,
+          source = highlightedItem.source;
+        source.onActive(_objectSpread({
+          event: event,
+          item: item,
+          itemInputValue: itemInputValue,
+          itemUrl: itemUrl,
+          refresh: refresh,
+          source: source,
+          state: store.getState()
+        }, setters));
+      }
+    }; // Default browser behavior changes the caret placement on ArrowUp and
+    // ArrowDown.
+    event.preventDefault();
+
+    // When re-opening the panel, we need to split the logic to keep the actions
+    // synchronized as `onInput` returns a promise.
+    if (store.getState().isOpen === false && (props.openOnFocus || Boolean(store.getState().query))) {
+      onInput(_objectSpread({
+        event: event,
+        props: props,
+        query: store.getState().query,
+        refresh: refresh,
+        store: store
+      }, setters)).then(function () {
+        store.dispatch(event.key, {
+          nextActiveItemId: props.defaultActiveItemId
+        });
+        triggerOnActive();
+        // Since we rely on the DOM, we need to wait for all the micro tasks to
+        // finish (which include re-opening the panel) to make sure all the
+        // elements are available.
+        setTimeout(triggerScrollIntoView, 0);
+      });
+    } else {
+      store.dispatch(event.key, {});
+      triggerOnActive();
+      triggerScrollIntoView();
+    }
+  } else if (event.key === 'Escape') {
+    // This prevents the default browser behavior on `input[type="search"]`
+    // from removing the query right away because we first want to close the
+    // panel.
+    event.preventDefault();
+    store.dispatch(event.key, null);
+
+    // Hitting the `Escape` key signals the end of a user interaction with the
+    // autocomplete. At this point, we should ignore any requests that are still
+    // pending and could reopen the panel once they resolve, because that would
+    // result in an unsolicited UI behavior.
+    store.pendingRequests.cancelAll();
+  } else if (event.key === 'Tab') {
+    store.dispatch('blur', null);
+
+    // Hitting the `Escape` key signals the end of a user interaction with the
+    // autocomplete. At this point, we should ignore any requests that are still
+    // pending and could reopen the panel once they resolve, because that would
+    // result in an unsolicited UI behavior.
+    store.pendingRequests.cancelAll();
+  } else if (event.key === 'Enter') {
+    // No active item, so we let the browser handle the native `onSubmit` form
+    // event.
+    if (store.getState().activeItemId === null || store.getState().collections.every(function (collection) {
+      return collection.items.length === 0;
+    })) {
+      // If requests are still pending when the panel closes, they could reopen
+      // the panel once they resolve.
+      // We want to prevent any subsequent query from reopening the panel
+      // because it would result in an unsolicited UI behavior.
+      if (!props.debug) {
+        store.pendingRequests.cancelAll();
+      }
+      return;
+    }
+
+    // This prevents the `onSubmit` event to be sent because an item is
+    // highlighted.
+    event.preventDefault();
+    var _ref2 = getActiveItem(store.getState()),
+      item = _ref2.item,
+      itemInputValue = _ref2.itemInputValue,
+      itemUrl = _ref2.itemUrl,
+      source = _ref2.source;
+    if (event.metaKey || event.ctrlKey) {
+      if (itemUrl !== undefined) {
+        source.onSelect(_objectSpread({
+          event: event,
+          item: item,
+          itemInputValue: itemInputValue,
+          itemUrl: itemUrl,
+          refresh: refresh,
+          source: source,
+          state: store.getState()
+        }, setters));
+        props.navigator.navigateNewTab({
+          itemUrl: itemUrl,
+          item: item,
+          state: store.getState()
+        });
+      }
+    } else if (event.shiftKey) {
+      if (itemUrl !== undefined) {
+        source.onSelect(_objectSpread({
+          event: event,
+          item: item,
+          itemInputValue: itemInputValue,
+          itemUrl: itemUrl,
+          refresh: refresh,
+          source: source,
+          state: store.getState()
+        }, setters));
+        props.navigator.navigateNewWindow({
+          itemUrl: itemUrl,
+          item: item,
+          state: store.getState()
+        });
+      }
+    } else if (event.altKey) {
+      // Keep native browser behavior
+    } else {
+      if (itemUrl !== undefined) {
+        source.onSelect(_objectSpread({
+          event: event,
+          item: item,
+          itemInputValue: itemInputValue,
+          itemUrl: itemUrl,
+          refresh: refresh,
+          source: source,
+          state: store.getState()
+        }, setters));
+        props.navigator.navigate({
+          itemUrl: itemUrl,
+          item: item,
+          state: store.getState()
+        });
+        return;
+      }
+      onInput(_objectSpread({
+        event: event,
+        nextState: {
+          isOpen: false
+        },
+        props: props,
+        query: itemInputValue,
+        refresh: refresh,
+        store: store
+      }, setters)).then(function () {
+        source.onSelect(_objectSpread({
+          event: event,
+          item: item,
+          itemInputValue: itemInputValue,
+          itemUrl: itemUrl,
+          refresh: refresh,
+          source: source,
+          state: store.getState()
+        }, setters));
+      });
+    }
+  }
+}

node_modules/@algolia/autocomplete-core/dist/esm/reshape.d.ts

@@ -0,0 +1,11 @@
+import { AutocompleteCollection, AutocompleteState, BaseItem, InternalAutocompleteOptions } from './types';
+declare type ReshapeParams<TItem extends BaseItem> = {
+    collections: Array<AutocompleteCollection<any>>;
+    props: InternalAutocompleteOptions<TItem>;
+    state: AutocompleteState<TItem>;
+};
+export declare function reshape<TItem extends BaseItem>({ collections, props, state, }: ReshapeParams<TItem>): {
+    source: import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteReshape").AutocompleteReshapeSource<TItem>;
+    items: TItem[];
+}[];
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/reshape.js

@@ -0,0 +1,45 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { flatten } from '@algolia/autocomplete-shared';
+export function reshape(_ref) {
+  var collections = _ref.collections,
+    props = _ref.props,
+    state = _ref.state;
+  // Sources are grouped by `sourceId` to conveniently pick them via destructuring.
+  // Example: `const { recentSearchesPlugin } = sourcesBySourceId`
+  var originalSourcesBySourceId = collections.reduce(function (acc, collection) {
+    return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, collection.source.sourceId, _objectSpread(_objectSpread({}, collection.source), {}, {
+      getItems: function getItems() {
+        // We provide the resolved items from the collection to the `reshape` prop.
+        return flatten(collection.items);
+      }
+    })));
+  }, {});
+  var _props$plugins$reduce = props.plugins.reduce(function (acc, plugin) {
+      if (plugin.reshape) {
+        return plugin.reshape(acc);
+      }
+      return acc;
+    }, {
+      sourcesBySourceId: originalSourcesBySourceId,
+      state: state
+    }),
+    sourcesBySourceId = _props$plugins$reduce.sourcesBySourceId;
+  var reshapeSources = props.reshape({
+    sourcesBySourceId: sourcesBySourceId,
+    sources: Object.values(sourcesBySourceId),
+    state: state
+  });
+
+  // We reconstruct the collections with the items modified by the `reshape` prop.
+  return flatten(reshapeSources).filter(Boolean).map(function (source) {
+    return {
+      source: source,
+      items: source.getItems()
+    };
+  });
+}

node_modules/@algolia/autocomplete-core/dist/esm/resolve.d.ts

@@ -0,0 +1,42 @@
+import type { ExecuteResponse, RequesterDescription, TransformResponse } from '@algolia/autocomplete-preset-algolia';
+import { MultipleQueriesQuery, SearchForFacetValuesResponse, SearchResponse } from '@algolia/client-search';
+import { AutocompleteState, AutocompleteStore, BaseItem, InternalAutocompleteSource } from './types';
+declare type RequestDescriptionPreResolved<TItem extends BaseItem> = Pick<RequesterDescription<TItem>, 'execute' | 'requesterId' | 'searchClient' | 'transformResponse'> & {
+    requests: Array<{
+        query: MultipleQueriesQuery;
+        sourceId: string;
+        transformResponse: TransformResponse<TItem>;
+    }>;
+};
+declare type RequestDescriptionPreResolvedCustom<TItem extends BaseItem> = {
+    items: TItem[] | TItem[][];
+    sourceId: string;
+    transformResponse?: undefined;
+};
+export declare function preResolve<TItem extends BaseItem>(itemsOrDescription: TItem[] | TItem[][] | RequesterDescription<TItem>, sourceId: string, state: AutocompleteState<TItem>): RequestDescriptionPreResolved<TItem> | RequestDescriptionPreResolvedCustom<TItem>;
+export declare function resolve<TItem extends BaseItem>(items: Array<RequestDescriptionPreResolved<TItem> | RequestDescriptionPreResolvedCustom<TItem>>): Promise<(RequestDescriptionPreResolvedCustom<TItem> | {
+    items: SearchForFacetValuesResponse | SearchResponse<TItem>;
+    sourceId: string;
+    transformResponse: TransformResponse<TItem>;
+})[]>;
+export declare function postResolve<TItem extends BaseItem>(responses: Array<RequestDescriptionPreResolvedCustom<TItem> | ExecuteResponse<TItem>[0]>, sources: Array<InternalAutocompleteSource<TItem>>, store: AutocompleteStore<TItem>): {
+    source: InternalAutocompleteSource<TItem>;
+    items: {
+        label: string;
+        count: number;
+        _highlightResult: {
+            label: {
+                value: string;
+            };
+        };
+    }[][] | {
+        label: string;
+        count: number;
+        _highlightResult: {
+            label: {
+                value: string;
+            };
+        };
+    }[] | import("@algolia/client-search").Hit<TItem>[] | (SearchForFacetValuesResponse | SearchResponse<TItem> | TItem[] | TItem[][])[];
+}[];
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/resolve.js

@@ -0,0 +1,114 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { decycle, flatten, invariant } from '@algolia/autocomplete-shared';
+import { mapToAlgoliaResponse } from './utils';
+function isDescription(item) {
+  return Boolean(item.execute);
+}
+function isRequesterDescription(description) {
+  return Boolean(description === null || description === void 0 ? void 0 : description.execute);
+}
+export function preResolve(itemsOrDescription, sourceId, state) {
+  if (isRequesterDescription(itemsOrDescription)) {
+    var contextParameters = itemsOrDescription.requesterId === 'algolia' ? Object.assign.apply(Object, [{}].concat(_toConsumableArray(Object.keys(state.context).map(function (key) {
+      var _state$context$key;
+      return (_state$context$key = state.context[key]) === null || _state$context$key === void 0 ? void 0 : _state$context$key.__algoliaSearchParameters;
+    })))) : {};
+    return _objectSpread(_objectSpread({}, itemsOrDescription), {}, {
+      requests: itemsOrDescription.queries.map(function (query) {
+        return {
+          query: itemsOrDescription.requesterId === 'algolia' ? _objectSpread(_objectSpread({}, query), {}, {
+            params: _objectSpread(_objectSpread({}, contextParameters), query.params)
+          }) : query,
+          sourceId: sourceId,
+          transformResponse: itemsOrDescription.transformResponse
+        };
+      })
+    });
+  }
+  return {
+    items: itemsOrDescription,
+    sourceId: sourceId
+  };
+}
+export function resolve(items) {
+  var packed = items.reduce(function (acc, current) {
+    if (!isDescription(current)) {
+      acc.push(current);
+      return acc;
+    }
+    var searchClient = current.searchClient,
+      execute = current.execute,
+      requesterId = current.requesterId,
+      requests = current.requests;
+    var container = acc.find(function (item) {
+      return isDescription(current) && isDescription(item) && item.searchClient === searchClient && Boolean(requesterId) && item.requesterId === requesterId;
+    });
+    if (container) {
+      var _container$items;
+      (_container$items = container.items).push.apply(_container$items, _toConsumableArray(requests));
+    } else {
+      var request = {
+        execute: execute,
+        requesterId: requesterId,
+        items: requests,
+        searchClient: searchClient
+      };
+      acc.push(request);
+    }
+    return acc;
+  }, []);
+  var values = packed.map(function (maybeDescription) {
+    if (!isDescription(maybeDescription)) {
+      return Promise.resolve(maybeDescription);
+    }
+    var _ref = maybeDescription,
+      execute = _ref.execute,
+      items = _ref.items,
+      searchClient = _ref.searchClient;
+    return execute({
+      searchClient: searchClient,
+      requests: items
+    });
+  });
+  return Promise.all(values).then(function (responses) {
+    return flatten(responses);
+  });
+}
+export function postResolve(responses, sources, store) {
+  return sources.map(function (source) {
+    var matches = responses.filter(function (response) {
+      return response.sourceId === source.sourceId;
+    });
+    var results = matches.map(function (_ref2) {
+      var items = _ref2.items;
+      return items;
+    });
+    var transform = matches[0].transformResponse;
+    var items = transform ? transform(mapToAlgoliaResponse(results)) : results;
+    source.onResolve({
+      source: source,
+      results: results,
+      items: items,
+      state: store.getState()
+    });
+    invariant(Array.isArray(items), function () {
+      return "The `getItems` function from source \"".concat(source.sourceId, "\" must return an array of items but returned type ").concat(JSON.stringify(_typeof(items)), ":\n\n").concat(JSON.stringify(decycle(items), null, 2), ".\n\nSee: https://www.algolia.com/doc/ui-libraries/autocomplete/core-concepts/sources/#param-getitems");
+    });
+    invariant(items.every(Boolean), "The `getItems` function from source \"".concat(source.sourceId, "\" must return an array of items but returned ").concat(JSON.stringify(undefined), ".\n\nDid you forget to return items?\n\nSee: https://www.algolia.com/doc/ui-libraries/autocomplete/core-concepts/sources/#param-getitems"));
+    return {
+      source: source,
+      items: items
+    };
+  });
+}

node_modules/@algolia/autocomplete-core/dist/esm/stateReducer.d.ts

@@ -0,0 +1,2 @@
+import { Reducer } from './types';
+export declare const stateReducer: Reducer;

node_modules/@algolia/autocomplete-core/dist/esm/stateReducer.js

@@ -0,0 +1,144 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { getItemsCount, invariant } from '@algolia/autocomplete-shared';
+import { getCompletion } from './getCompletion';
+import { getNextActiveItemId } from './utils';
+export var stateReducer = function stateReducer(state, action) {
+  switch (action.type) {
+    case 'setActiveItemId':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          activeItemId: action.payload
+        });
+      }
+    case 'setQuery':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          query: action.payload,
+          completion: null
+        });
+      }
+    case 'setCollections':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          collections: action.payload
+        });
+      }
+    case 'setIsOpen':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          isOpen: action.payload
+        });
+      }
+    case 'setStatus':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          status: action.payload
+        });
+      }
+    case 'setContext':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          context: _objectSpread(_objectSpread({}, state.context), action.payload)
+        });
+      }
+    case 'ArrowDown':
+      {
+        var nextState = _objectSpread(_objectSpread({}, state), {}, {
+          activeItemId: action.payload.hasOwnProperty('nextActiveItemId') ? action.payload.nextActiveItemId : getNextActiveItemId(1, state.activeItemId, getItemsCount(state), action.props.defaultActiveItemId)
+        });
+        return _objectSpread(_objectSpread({}, nextState), {}, {
+          completion: getCompletion({
+            state: nextState
+          })
+        });
+      }
+    case 'ArrowUp':
+      {
+        var _nextState = _objectSpread(_objectSpread({}, state), {}, {
+          activeItemId: getNextActiveItemId(-1, state.activeItemId, getItemsCount(state), action.props.defaultActiveItemId)
+        });
+        return _objectSpread(_objectSpread({}, _nextState), {}, {
+          completion: getCompletion({
+            state: _nextState
+          })
+        });
+      }
+    case 'Escape':
+      {
+        if (state.isOpen) {
+          return _objectSpread(_objectSpread({}, state), {}, {
+            activeItemId: null,
+            isOpen: false,
+            completion: null
+          });
+        }
+        return _objectSpread(_objectSpread({}, state), {}, {
+          activeItemId: null,
+          query: '',
+          status: 'idle',
+          collections: []
+        });
+      }
+    case 'submit':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          activeItemId: null,
+          isOpen: false,
+          status: 'idle'
+        });
+      }
+    case 'reset':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          activeItemId:
+          // Since we open the panel on reset when openOnFocus=true
+          // we need to restore the highlighted index to the defaultActiveItemId. (DocSearch use-case)
+
+          // Since we close the panel when openOnFocus=false
+          // we lose track of the highlighted index. (Query-suggestions use-case)
+          action.props.openOnFocus === true ? action.props.defaultActiveItemId : null,
+          status: 'idle',
+          query: ''
+        });
+      }
+    case 'focus':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          activeItemId: action.props.defaultActiveItemId,
+          isOpen: (action.props.openOnFocus || Boolean(state.query)) && action.props.shouldPanelOpen({
+            state: state
+          })
+        });
+      }
+    case 'blur':
+      {
+        if (action.props.debug) {
+          return state;
+        }
+        return _objectSpread(_objectSpread({}, state), {}, {
+          isOpen: false,
+          activeItemId: null
+        });
+      }
+    case 'mousemove':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          activeItemId: action.payload
+        });
+      }
+    case 'mouseleave':
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          activeItemId: action.props.defaultActiveItemId
+        });
+      }
+    default:
+      invariant(false, "The reducer action ".concat(JSON.stringify(action.type), " is not supported."));
+      return state;
+  }
+};

node_modules/@algolia/autocomplete-core/dist/esm/types/AutocompleteStore.d.ts

@@ -0,0 +1,15 @@
+import { CancelablePromiseList } from '../utils';
+import { BaseItem, InternalAutocompleteOptions, AutocompleteState } from './';
+export interface AutocompleteStore<TItem extends BaseItem> {
+    getState(): AutocompleteState<TItem>;
+    dispatch(action: ActionType, payload: any): void;
+    pendingRequests: CancelablePromiseList<void>;
+}
+export declare type Reducer = <TItem extends BaseItem>(state: AutocompleteState<TItem>, action: Action<TItem, any>) => AutocompleteState<TItem>;
+declare type Action<TItem extends BaseItem, TPayload> = {
+    type: ActionType;
+    props: InternalAutocompleteOptions<TItem>;
+    payload: TPayload;
+};
+export declare type ActionType = 'setActiveItemId' | 'setQuery' | 'setCollections' | 'setIsOpen' | 'setStatus' | 'setContext' | 'ArrowUp' | 'ArrowDown' | 'Escape' | 'Enter' | 'submit' | 'reset' | 'focus' | 'blur' | 'mousemove' | 'mouseleave' | 'click';
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/types/AutocompleteStore.js

@@ -0,0 +1 @@
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/types/AutocompleteSubscribers.d.ts

@@ -0,0 +1,7 @@
+import { BaseItem, OnActiveParams, OnResolveParams, OnSelectParams } from './';
+export declare type AutocompleteSubscriber<TItem extends BaseItem> = {
+    onSelect(params: OnSelectParams<TItem>): void;
+    onActive(params: OnActiveParams<TItem>): void;
+    onResolve(params: OnResolveParams<TItem>): void;
+};
+export declare type AutocompleteSubscribers<TItem extends BaseItem> = Array<Partial<AutocompleteSubscriber<TItem>>>;

node_modules/@algolia/autocomplete-core/dist/esm/types/AutocompleteSubscribers.js

@@ -0,0 +1 @@
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/types/index.d.ts

@@ -0,0 +1,18 @@
+export * from '@algolia/autocomplete-shared/dist/esm/core';
+export * from './AutocompleteStore';
+export * from './AutocompleteSubscribers';
+import { CreateAlgoliaInsightsPluginParams, AutocompleteInsightsApi as _AutocompleteInsightsApi, AlgoliaInsightsHit as _AlgoliaInsightsHit } from '@algolia/autocomplete-plugin-algolia-insights';
+import { AutocompleteOptions as _AutocompleteOptions, BaseItem } from '@algolia/autocomplete-shared/dist/esm/core';
+export declare type AutocompleteInsightsApi = _AutocompleteInsightsApi;
+export declare type AlgoliaInsightsHit = _AlgoliaInsightsHit;
+export interface AutocompleteOptions<TItem extends BaseItem> extends _AutocompleteOptions<TItem> {
+    /**
+     * Whether to enable the Insights plugin and load the Insights library if it has not been loaded yet.
+     *
+     * See [**autocomplete-plugin-algolia-insights**](https://www.algolia.com/doc/ui-libraries/autocomplete/api-reference/autocomplete-plugin-algolia-insights/) for more information.
+     *
+     * @default false
+     * @link https://www.algolia.com/doc/ui-libraries/autocomplete/api-reference/autocomplete-js/autocomplete/#param-insights
+     */
+    insights?: CreateAlgoliaInsightsPluginParams | boolean;
+}

node_modules/@algolia/autocomplete-core/dist/esm/types/index.js

@@ -0,0 +1,4 @@
+export * from '@algolia/autocomplete-shared/dist/esm/core';
+export * from './AutocompleteStore';
+export * from './AutocompleteSubscribers';
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/utils/createCancelablePromise.d.ts

@@ -0,0 +1,15 @@
+declare type PromiseExecutor<TValue> = (resolve: (value: TValue | PromiseLike<TValue>) => void, reject: (reason?: any) => void) => void;
+export declare type CancelablePromise<TValue> = {
+    then<TResultFulfilled = TValue, TResultRejected = never>(onfulfilled?: ((value: TValue) => TResultFulfilled | PromiseLike<TResultFulfilled> | CancelablePromise<TResultFulfilled>) | undefined | null, onrejected?: ((reason: any) => TResultRejected | PromiseLike<TResultRejected> | CancelablePromise<TResultRejected>) | undefined | null): CancelablePromise<TResultFulfilled | TResultRejected>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult> | CancelablePromise<TResult>) | undefined | null): CancelablePromise<TValue | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): CancelablePromise<TValue>;
+    cancel(): void;
+    isCanceled(): boolean;
+};
+export declare function createCancelablePromise<TValue>(executor: PromiseExecutor<TValue>): CancelablePromise<TValue>;
+export declare namespace createCancelablePromise {
+    var resolve: <TValue>(value?: TValue | PromiseLike<TValue> | CancelablePromise<TValue> | undefined) => CancelablePromise<TValue | CancelablePromise<TValue> | undefined>;
+    var reject: (reason?: any) => CancelablePromise<never>;
+}
+export declare function cancelable<TValue>(promise: Promise<TValue>): CancelablePromise<TValue>;
+export {};

node_modules/@algolia/autocomplete-core/dist/esm/utils/createCancelablePromise.js

@@ -0,0 +1,62 @@
+function createInternalCancelablePromise(promise, initialState) {
+  var state = initialState;
+  return {
+    then: function then(onfulfilled, onrejected) {
+      return createInternalCancelablePromise(promise.then(createCallback(onfulfilled, state, promise), createCallback(onrejected, state, promise)), state);
+    },
+    catch: function _catch(onrejected) {
+      return createInternalCancelablePromise(promise.catch(createCallback(onrejected, state, promise)), state);
+    },
+    finally: function _finally(onfinally) {
+      if (onfinally) {
+        state.onCancelList.push(onfinally);
+      }
+      return createInternalCancelablePromise(promise.finally(createCallback(onfinally && function () {
+        state.onCancelList = [];
+        return onfinally();
+      }, state, promise)), state);
+    },
+    cancel: function cancel() {
+      state.isCanceled = true;
+      var callbacks = state.onCancelList;
+      state.onCancelList = [];
+      callbacks.forEach(function (callback) {
+        callback();
+      });
+    },
+    isCanceled: function isCanceled() {
+      return state.isCanceled === true;
+    }
+  };
+}
+export function createCancelablePromise(executor) {
+  return createInternalCancelablePromise(new Promise(function (resolve, reject) {
+    return executor(resolve, reject);
+  }), {
+    isCanceled: false,
+    onCancelList: []
+  });
+}
+createCancelablePromise.resolve = function (value) {
+  return cancelable(Promise.resolve(value));
+};
+createCancelablePromise.reject = function (reason) {
+  return cancelable(Promise.reject(reason));
+};
+export function cancelable(promise) {
+  return createInternalCancelablePromise(promise, {
+    isCanceled: false,
+    onCancelList: []
+  });
+}
+function createCallback(onResult, state, fallback) {
+  if (!onResult) {
+    return fallback;
+  }
+  return function callback(arg) {
+    if (state.isCanceled) {
+      return arg;
+    }
+    return onResult(arg);
+  };
+}

node_modules/@algolia/autocomplete-core/dist/esm/utils/createCancelablePromiseList.d.ts

@@ -0,0 +1,21 @@
+import { CancelablePromise } from '.';
+export declare type CancelablePromiseList<TValue> = {
+    /**
+     * Add a cancelable promise to the list.
+     *
+     * @param cancelablePromise The cancelable promise to add.
+     */
+    add(cancelablePromise: CancelablePromise<TValue>): CancelablePromise<TValue>;
+    /**
+     * Cancel all pending promises.
+     *
+     * Requests aren't actually stopped. All pending promises will settle, but
+     * attached handlers won't run.
+     */
+    cancelAll(): void;
+    /**
+     * Whether there are pending promises in the list.
+     */
+    isEmpty(): boolean;
+};
+export declare function createCancelablePromiseList<TValue>(): CancelablePromiseList<TValue>;

node_modules/@algolia/autocomplete-core/dist/esm/utils/createCancelablePromiseList.js

@@ -0,0 +1,21 @@
+export function createCancelablePromiseList() {
+  var list = [];
+  return {
+    add: function add(cancelablePromise) {
+      list.push(cancelablePromise);
+      return cancelablePromise.finally(function () {
+        list = list.filter(function (item) {
+          return item !== cancelablePromise;
+        });
+      });
+    },
+    cancelAll: function cancelAll() {
+      list.forEach(function (promise) {
+        return promise.cancel();
+      });
+    },
+    isEmpty: function isEmpty() {
+      return list.length === 0;
+    }
+  };
+}

node_modules/@algolia/autocomplete-core/dist/esm/utils/createConcurrentSafePromise.d.ts

@@ -0,0 +1,8 @@
+import { MaybePromise } from '@algolia/autocomplete-shared';
+/**
+ * Creates a runner that executes promises in a concurrent-safe way.
+ *
+ * This is useful to prevent older promises to resolve after a newer promise,
+ * otherwise resulting in stale resolved values.
+ */
+export declare function createConcurrentSafePromise(): <TValue>(promise: MaybePromise<TValue>) => Promise<TValue>;

node_modules/@algolia/autocomplete-core/dist/esm/utils/createConcurrentSafePromise.js

@@ -0,0 +1,36 @@
+/**
+ * Creates a runner that executes promises in a concurrent-safe way.
+ *
+ * This is useful to prevent older promises to resolve after a newer promise,
+ * otherwise resulting in stale resolved values.
+ */
+export function createConcurrentSafePromise() {
+  var basePromiseId = -1;
+  var latestResolvedId = -1;
+  var latestResolvedValue = undefined;
+  return function runConcurrentSafePromise(promise) {
+    basePromiseId++;
+    var currentPromiseId = basePromiseId;
+    return Promise.resolve(promise).then(function (x) {
+      // The promise might take too long to resolve and get outdated. This would
+      // result in resolving stale values.
+      // When this happens, we ignore the promise value and return the one
+      // coming from the latest resolved value.
+      //
+      // +----------------------------------+
+      // |        100ms                     |
+      // | run(1) +--->  R1                 |
+      // |        300ms                     |
+      // | run(2) +-------------> R2 (SKIP) |
+      // |        200ms                     |
+      // | run(3) +--------> R3             |
+      // +----------------------------------+
+      if (latestResolvedValue && currentPromiseId < latestResolvedId) {
+        return latestResolvedValue;
+      }
+      latestResolvedId = currentPromiseId;
+      latestResolvedValue = x;
+      return x;
+    });
+  };
+}

node_modules/@algolia/autocomplete-core/dist/esm/utils/getActiveItem.d.ts

@@ -0,0 +1,7 @@
+import { AutocompleteState, BaseItem } from '../types';
+export declare function getActiveItem<TItem extends BaseItem>(state: AutocompleteState<TItem>): {
+    item: TItem;
+    itemInputValue: string;
+    itemUrl: string | undefined;
+    source: import("@algolia/autocomplete-shared/dist/esm/core/AutocompleteSource").InternalAutocompleteSource<TItem>;
+} | null;

node_modules/@algolia/autocomplete-core/dist/esm/utils/getActiveItem.js

@@ -0,0 +1,77 @@
+// We don't have access to the autocomplete source when we call `onKeyDown`
+// or `onClick` because those are native browser events.
+// However, we can get the source from the suggestion index.
+function getCollectionFromActiveItemId(state) {
+  // Given 3 sources with respectively 1, 2 and 3 suggestions: [1, 2, 3]
+  // We want to get the accumulated counts:
+  // [1, 1 + 2, 1 + 2 + 3] = [1, 3, 3 + 3] = [1, 3, 6]
+  var accumulatedCollectionsCount = state.collections.map(function (collections) {
+    return collections.items.length;
+  }).reduce(function (acc, collectionsCount, index) {
+    var previousValue = acc[index - 1] || 0;
+    var nextValue = previousValue + collectionsCount;
+    acc.push(nextValue);
+    return acc;
+  }, []);
+
+  // Based on the accumulated counts, we can infer the index of the suggestion.
+  var collectionIndex = accumulatedCollectionsCount.reduce(function (acc, current) {
+    if (current <= state.activeItemId) {
+      return acc + 1;
+    }
+    return acc;
+  }, 0);
+  return state.collections[collectionIndex];
+}
+
+/**
+ * Gets the highlighted index relative to a suggestion object (not the absolute
+ * highlighted index).
+ *
+ * Example:
+ *  [['a', 'b'], ['c', 'd', 'e'], ['f']]
+ *                      ↑
+ *         (absolute: 3, relative: 1)
+ */
+function getRelativeActiveItemId(_ref) {
+  var state = _ref.state,
+    collection = _ref.collection;
+  var isOffsetFound = false;
+  var counter = 0;
+  var previousItemsOffset = 0;
+  while (isOffsetFound === false) {
+    var currentCollection = state.collections[counter];
+    if (currentCollection === collection) {
+      isOffsetFound = true;
+      break;
+    }
+    previousItemsOffset += currentCollection.items.length;
+    counter++;
+  }
+  return state.activeItemId - previousItemsOffset;
+}
+export function getActiveItem(state) {
+  var collection = getCollectionFromActiveItemId(state);
+  if (!collection) {
+    return null;
+  }
+  var item = collection.items[getRelativeActiveItemId({
+    state: state,
+    collection: collection
+  })];
+  var source = collection.source;
+  var itemInputValue = source.getItemInputValue({
+    item: item,
+    state: state
+  });
+  var itemUrl = source.getItemUrl({
+    item: item,
+    state: state
+  });
+  return {
+    item: item,
+    itemInputValue: itemInputValue,
+    itemUrl: itemUrl,
+    source: source
+  };
+}

node_modules/@algolia/autocomplete-core/dist/esm/utils/getNextActiveItemId.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns the next active item ID from the current state.
+ *
+ * We allow circular keyboard navigation from the base index.
+ * The base index can either be `null` (nothing is highlighted) or `0`
+ * (the first item is highlighted).
+ * The base index is allowed to get assigned `null` only if
+ * `props.defaultActiveItemId` is `null`. This pattern allows to "stop"
+ * by the actual query before navigating to other suggestions as seen on
+ * Google or Amazon.
+ *
+ * @param moveAmount The offset to increment (or decrement) the last index
+ * @param baseIndex The current index to compute the next index from
+ * @param itemCount The number of items
+ * @param defaultActiveItemId The default active index to fallback to
+ */
+export declare function getNextActiveItemId(moveAmount: number, baseIndex: number | null, itemCount: number, defaultActiveItemId: number | null): number | null;

node_modules/@algolia/autocomplete-core/dist/esm/utils/getNextActiveItemId.js

@@ -0,0 +1,29 @@
+/**
+ * Returns the next active item ID from the current state.
+ *
+ * We allow circular keyboard navigation from the base index.
+ * The base index can either be `null` (nothing is highlighted) or `0`
+ * (the first item is highlighted).
+ * The base index is allowed to get assigned `null` only if
+ * `props.defaultActiveItemId` is `null`. This pattern allows to "stop"
+ * by the actual query before navigating to other suggestions as seen on
+ * Google or Amazon.
+ *
+ * @param moveAmount The offset to increment (or decrement) the last index
+ * @param baseIndex The current index to compute the next index from
+ * @param itemCount The number of items
+ * @param defaultActiveItemId The default active index to fallback to
+ */
+export function getNextActiveItemId(moveAmount, baseIndex, itemCount, defaultActiveItemId) {
+  if (!itemCount) {
+    return null;
+  }
+  if (moveAmount < 0 && (baseIndex === null || defaultActiveItemId !== null && baseIndex === 0)) {
+    return itemCount + moveAmount;
+  }
+  var numericIndex = (baseIndex === null ? -1 : baseIndex) + moveAmount;
+  if (numericIndex <= -1 || numericIndex >= itemCount) {
+    return defaultActiveItemId === null ? null : 0;
+  }
+  return numericIndex;
+}

node_modules/@algolia/autocomplete-core/dist/esm/utils/getNormalizedSources.d.ts

@@ -0,0 +1,2 @@
+import { BaseItem, GetSources, GetSourcesParams, InternalGetSources } from '../types';
+export declare function getNormalizedSources<TItem extends BaseItem>(getSources: GetSources<TItem>, params: GetSourcesParams<TItem>): ReturnType<InternalGetSources<TItem>>;

node_modules/@algolia/autocomplete-core/dist/esm/utils/getNormalizedSources.js

@@ -0,0 +1,48 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+import { invariant, decycle, noop } from '@algolia/autocomplete-shared';
+export function getNormalizedSources(getSources, params) {
+  var seenSourceIds = [];
+  return Promise.resolve(getSources(params)).then(function (sources) {
+    invariant(Array.isArray(sources), function () {
+      return "The `getSources` function must return an array of sources but returned type ".concat(JSON.stringify(_typeof(sources)), ":\n\n").concat(JSON.stringify(decycle(sources), null, 2));
+    });
+    return Promise.all(sources
+    // We allow `undefined` and `false` sources to allow users to use
+    // `Boolean(query) && source` (=> `false`).
+    // We need to remove these values at this point.
+    .filter(function (maybeSource) {
+      return Boolean(maybeSource);
+    }).map(function (source) {
+      invariant(typeof source.sourceId === 'string', 'A source must provide a `sourceId` string.');
+      if (seenSourceIds.includes(source.sourceId)) {
+        throw new Error("[Autocomplete] The `sourceId` ".concat(JSON.stringify(source.sourceId), " is not unique."));
+      }
+      seenSourceIds.push(source.sourceId);
+      var defaultSource = {
+        getItemInputValue: function getItemInputValue(_ref) {
+          var state = _ref.state;
+          return state.query;
+        },
+        getItemUrl: function getItemUrl() {
+          return undefined;
+        },
+        onSelect: function onSelect(_ref2) {
+          var setIsOpen = _ref2.setIsOpen;
+          setIsOpen(false);
+        },
+        onActive: noop,
+        onResolve: noop
+      };
+      Object.keys(defaultSource).forEach(function (key) {
+        defaultSource[key].__default = true;
+      });
+      var normalizedSource = _objectSpread(_objectSpread({}, defaultSource), source);
+      return Promise.resolve(normalizedSource);
+    }));
+  });
+}

node_modules/@algolia/autocomplete-core/dist/esm/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './createCancelablePromise';
+export * from './createCancelablePromiseList';
+export * from './createConcurrentSafePromise';
+export * from './getNextActiveItemId';
+export * from './getNormalizedSources';
+export * from './getActiveItem';
+export * from './isOrContainsNode';
+export * from './isSamsung';
+export * from './mapToAlgoliaResponse';

node_modules/@algolia/autocomplete-core/dist/esm/utils/index.js

@@ -0,0 +1,9 @@
+export * from './createCancelablePromise';
+export * from './createCancelablePromiseList';
+export * from './createConcurrentSafePromise';
+export * from './getNextActiveItemId';
+export * from './getNormalizedSources';
+export * from './getActiveItem';
+export * from './isOrContainsNode';
+export * from './isSamsung';
+export * from './mapToAlgoliaResponse';

node_modules/@algolia/autocomplete-core/dist/esm/utils/isOrContainsNode.d.ts

@@ -0,0 +1 @@
+export declare function isOrContainsNode(parent: Node, child: Node): boolean;

node_modules/@algolia/autocomplete-core/dist/esm/utils/isOrContainsNode.js

@@ -0,0 +1,3 @@
+export function isOrContainsNode(parent, child) {
+  return parent === child || parent.contains(child);
+}

node_modules/@algolia/autocomplete-core/dist/esm/utils/isSamsung.d.ts

@@ -0,0 +1 @@
+export declare function isSamsung(userAgent: string): boolean;

node_modules/@algolia/autocomplete-core/dist/esm/utils/isSamsung.js

@@ -0,0 +1,4 @@
+var regex = /((gt|sm)-|galaxy nexus)|samsung[- ]|samsungbrowser/i;
+export function isSamsung(userAgent) {
+  return Boolean(userAgent && userAgent.match(regex));
+}

node_modules/@algolia/autocomplete-core/dist/esm/utils/mapToAlgoliaResponse.d.ts

@@ -0,0 +1,14 @@
+import type { SearchForFacetValuesResponse, SearchResponse } from '@algolia/client-search';
+export declare function mapToAlgoliaResponse<THit>(rawResults: Array<SearchResponse<THit> | SearchForFacetValuesResponse>): {
+    results: (SearchResponse<THit> | SearchForFacetValuesResponse)[];
+    hits: import("@algolia/client-search").Hit<THit>[][];
+    facetHits: {
+        label: string;
+        count: number;
+        _highlightResult: {
+            label: {
+                value: string;
+            };
+        };
+    }[][];
+};

node_modules/@algolia/autocomplete-core/dist/esm/utils/mapToAlgoliaResponse.js

@@ -0,0 +1,23 @@
+export function mapToAlgoliaResponse(rawResults) {
+  return {
+    results: rawResults,
+    hits: rawResults.map(function (result) {
+      return result.hits;
+    }).filter(Boolean),
+    facetHits: rawResults.map(function (result) {
+      var _facetHits;
+      return (_facetHits = result.facetHits) === null || _facetHits === void 0 ? void 0 : _facetHits.map(function (facetHit) {
+        // Bring support for the highlighting components.
+        return {
+          label: facetHit.value,
+          count: facetHit.count,
+          _highlightResult: {
+            label: {
+              value: facetHit.highlighted
+            }
+          }
+        };
+      });
+    }).filter(Boolean)
+  };
+}