{"version":3,"sources":["webpack:///./node_modules/events/events.js","webpack:///./node_modules/algoliasearch-helper/src/requestBuilder.js","webpack:///./node_modules/algoliasearch-helper/src/version.js","webpack:///./node_modules/algoliasearch-helper/src/algoliasearch.helper.js","webpack:///./node_modules/react-side-effect/lib/index.js","webpack:///./node_modules/core-js/modules/es.array.reduce-right.js","webpack:///./src/components/lands-logo.js","webpack:///./src/components/language.js","webpack:///./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectSpread.js","webpack:///./node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack:///./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack:///./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack:///./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","webpack:///./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack:///./node_modules/@babel/runtime/helpers/esm/createClass.js","webpack:///./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack:///./node_modules/@babel/runtime/helpers/esm/inherits.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/utils.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/createWidgetsManager.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/highlight.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/indexUtils.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/createInstantSearchManager.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/version.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/createStore.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/context.js","webpack:///./node_modules/react-instantsearch-core/dist/es/widgets/InstantSearch.js","webpack:///./node_modules/@babel/runtime/helpers/esm/extends.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/createConnector.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectConfigure.js","webpack:///./node_modules/react-instantsearch-core/dist/es/widgets/Configure.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectSearchBox.js","webpack:///./src/components/search/search-box.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectStateResults.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectHighlight.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectPoweredBy.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectHits.js","webpack:///./node_modules/react-instantsearch-core/dist/es/widgets/Index.js","webpack:///./src/components/search/algolia-logo.js","webpack:///./src/components/search/search-result.js","webpack:///./src/components/search/use-click-outside.js","webpack:///./src/components/search/index.js","webpack:///./src/components/header.js","webpack:///./src/components/layout.js","webpack:///./node_modules/algoliasearch-helper/src/functions/formatSort.js","webpack:///./node_modules/algoliasearch/dist/algoliasearch-lite.umd.js","webpack:///./node_modules/algoliasearch-helper/src/functions/merge.js","webpack:///./node_modules/algoliasearch-helper/src/functions/find.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/RefinementList.js","webpack:///./node_modules/algoliasearch-helper/src/DerivedHelper/index.js","webpack:///./node_modules/algoliasearch-helper/index.js","webpack:///./node_modules/algoliasearch-helper/src/functions/inherits.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/index.js","webpack:///./node_modules/algoliasearch-helper/src/functions/intersection.js","webpack:///./node_modules/algoliasearch-helper/src/utils/isValidUserToken.js","webpack:///./node_modules/algoliasearch-helper/src/functions/compact.js","webpack:///./node_modules/react-fast-compare/index.js","webpack:///./node_modules/algoliasearch-helper/src/functions/objectHasKeys.js","webpack:///./node_modules/algoliasearch-helper/src/functions/defaultsPure.js","webpack:///./node_modules/algoliasearch-helper/src/SearchResults/generate-hierarchical-tree.js","webpack:///./node_modules/algoliasearch-helper/src/functions/valToNumber.js","webpack:///./node_modules/algoliasearch-helper/src/functions/findIndex.js","webpack:///./node_modules/algoliasearch-helper/src/functions/omit.js","webpack:///./node_modules/react-helmet/es/Helmet.js","webpack:///./node_modules/algoliasearch-helper/src/SearchResults/index.js","webpack:///./src/components/seo.js","webpack:///./node_modules/algoliasearch-helper/src/functions/orderBy.js","webpack:///(webpack)/buildin/global.js"],"names":["ReflectOwnKeys","R","Reflect","ReflectApply","apply","target","receiver","args","Function","prototype","call","ownKeys","Object","getOwnPropertySymbols","getOwnPropertyNames","concat","NumberIsNaN","Number","isNaN","value","EventEmitter","init","this","module","exports","once","emitter","name","Promise","resolve","reject","eventListener","undefined","errorListener","removeListener","slice","arguments","err","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","TypeError","_getMaxListeners","that","_addListener","type","prepend","m","events","existing","warning","create","newListener","emit","unshift","push","length","warned","w","Error","String","count","console","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","arr","ret","Array","i","unwrapListeners","arrayClone","listenerCount","n","copy","defineProperty","enumerable","get","set","arg","RangeError","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","message","context","handler","len","listeners","addListener","on","prependListener","prependOnceListener","list","position","originalListener","shift","index","pop","spliceOne","off","removeAllListeners","key","keys","rawListeners","eventNames","merge","requestBuilder","_getQueries","queries","indexName","params","_getHitsSearchParams","getRefinedDisjunctiveFacets","forEach","refinedFacet","_getDisjunctiveFacetSearchParams","getRefinedHierarchicalFacets","hierarchicalFacet","getHierarchicalFacetByName","currentRefinement","getHierarchicalRefinement","separator","_getHierarchicalFacetSeparator","split","facets","disjunctiveFacets","_getHitsHierarchicalFacetsAttributes","facetFilters","_getFacetFilters","numericFilters","_getNumericFilters","additionalParams","tagFilters","_getTagFilters","getQueryParams","facet","hierarchicalRootLevel","hitsPerPage","page","attributesToRetrieve","attributesToHighlight","attributesToSnippet","analytics","clickAnalytics","_getDisjunctiveHierarchicalFacetAttribute","facetName","numericRefinements","attribute","operators","operator","values","isArray","vs","map","v","tagRefinements","join","facetsRefinements","facetValue","facetsExcludes","disjunctiveFacetsRefinements","facetValues","orFilters","hierarchicalFacetsRefinements","attributeToRefine","attributesIndex","rootPath","_getHierarchicalRootPath","indexOf","lastIndexOf","attributes","hierarchicalFacets","reduce","allAttributes","hierarchicalRefinement","level","newAttributes","rootLevel","attributeIndex","parentLevel","getSearchForFacetQuery","query","maxFacetHits","stateForSearchForFacetValues","isDisjunctiveFacet","clearRefinements","searchForFacetSearchParameters","facetQuery","SearchParameters","SearchResults","DerivedHelper","inherits","objectHasKeys","version","AlgoliaSearchHelper","client","options","addAlgoliaAgent","setClient","opts","make","lastResults","_queryId","_lastQueryIdReceived","derivedHelpers","_currentNbQueries","setCurrentPage","_change","setPage","isPageReset","getCurrentPage","search","_search","onlyWithDerivedHelpers","searchOnlyWithDerivedHelpers","getQuery","searchOnce","cb","tempState","setQueryParameters","self","then","content","results","_originalResponse","e","catch","searchForFacetValues","userState","clientHasSFFV","initIndex","isDisjunctive","algoliaQuery","facetHits","f","isRefined","isDisjunctiveFacetRefined","isFacetRefined","setQuery","q","resetPage","clearTags","addDisjunctiveFacetRefinement","addDisjunctiveRefine","addHierarchicalFacetRefinement","addNumericRefinement","addFacetRefinement","addRefine","addFacetExclusion","addExcludeRefinement","addExclude","addTag","tag","addTagRefinement","removeNumericRefinement","removeDisjunctiveFacetRefinement","removeDisjunctiveRefine","removeHierarchicalFacetRefinement","removeFacetRefinement","removeRefine","removeFacetExclusion","removeExcludeRefinement","removeExclude","removeTag","removeTagRefinement","toggleFacetExclusion","toggleExcludeFacetRefinement","toggleExclude","toggleRefinement","toggleFacetRefinement","toggleRefine","toggleTag","toggleTagRefinement","nextPage","previousPage","setIndex","setQueryParameter","parameter","setState","newState","overrideStateWithoutTriggeringChangeEvent","hasRefinements","getNumericRefinements","isConjunctiveFacet","isHierarchicalFacet","isHierarchicalFacetRefined","isExcluded","isExcludeRefined","isDisjunctiveRefined","hasTag","isTagRefined","hasTagRefinements","getIndex","getPage","getTags","getRefinements","refinements","getConjunctiveRefinements","r","getExcludeRefinements","getDisjunctiveRefinements","getNumericRefinement","getHierarchicalFacetBreadcrumb","states","mainQueries","queriesCount","helper","derivedQueries","derivedHelper","derivedState","getModifiedState","derivedStateQueries","queryId","_dispatchAlgoliaResponse","_dispatchAlgoliaError","s","specificResults","splice","formattedResponse","containsRefinement","_hasDisjunctiveRefinements","disjunctiveRefinements","event","clearCache","newClient","getClient","derive","fn","detachDerivedHelper","pos","hasPendingRequests","ex","React","React__default","_defineProperty","obj","configurable","writable","canUseDOM","window","document","createElement","reducePropsToState","handleStateChangeOnClient","mapStateOnServer","WrappedComponent","mountedInstances","emitChange","instance","props","SideEffect","_PureComponent","subClass","superClass","constructor","__proto__","peek","rewind","recordedState","_proto","UNSAFE_componentWillMount","componentDidUpdate","componentWillUnmount","render","PureComponent","displayName","getDisplayName","$","$reduceRight","right","arrayMethodIsStrict","arrayMethodUsesToLength","CHROME_VERSION","IS_NODE","STRICT_METHOD","USES_TO_LENGTH","1","proto","forced","reduceRight","callbackfn","LandsLogo","rootCssClasses","viewBox","className","d","fill","opacity","defaultProps","Language","useIntl","lang","storeLang","translations","languages","useStaticQuery","allLanguage","nodes","useMemo","translationsData","languagesData","find","l","locale","createLangOptions","htmlFor","id","onChange","navigate","_objectSpread","source","filter","sym","getOwnPropertyDescriptor","_classCallCheck","Constructor","_typeof","Symbol","iterator","_assertThisInitialized","ReferenceError","_possibleConstructorReturn","_getPrototypeOf","o","setPrototypeOf","_defineProperties","descriptor","_createClass","protoProps","staticProps","_setPrototypeOf","p","_inherits","_objectWithoutProperties","excluded","sourceKeys","sourceSymbolKeys","propertyIsEnumerable","shallowEqual","objA","objB","keysA","keysB","hasOwn","hasOwnProperty","resolved","removeEmptyKey","object","omit","_key","createWidgetsManager","onWidgetsUpdate","widgets","scheduled","scheduleUpdate","registerWidget","widget","update","getWidgets","HIGHLIGHT_TAGS","highlightPreTag","highlightPostTag","parseHighlightedAttribute","_ref","preTag","postTag","_ref$highlightedValue","highlightedValue","splitByPreTag","firstValue","elements","isHighlighted","splitByPostTag","parseAlgoliaHit","_ref2","_ref2$preTag","_ref2$postTag","highlightProperty","hit","path","highlightObject","replace","current","item","getIndexId","hasMultipleIndices","multiIndexContext","targetedIndex","ais","mainTargetedIndex","getResults","searchResults","hits","indexId","refineValue","searchState","nextRefinement","namespace","_objectSpread4","indices","refineMultiIndexWithNamespace","refineMultiIndex","refineSingleIndexWithNamespace","refineSingleIndex","getNamespaceAndAttributeName","parts","match","attributeName","getCurrentRefinementValue","defaultValue","_getNamespaceAndAttri","multiIndex","defaultRefinement","cleanUpValue","_getNamespaceAndAttri2","Boolean","_ref4","indexSearchState","cleanUpValueWithMultiIndex","_ref3","cleanUpValueWithSingleIndex","addAlgoliaAgents","searchClient","contextValue","indexContextValue","isTargetedIndexEqualIndex","isIndexWidget","isIndexWidgetEqualIndex","sortIndexWidgetsFirst","firstWidget","secondWidget","isFirstWidgetIndex","isSecondWidgetIndex","serializeQueryParameters","parameters","format","_len","encodeURIComponent","encode","toString","JSON","stringify","createInstantSearchManager","_ref$initialState","initialState","resultsState","stalledSearchDelay","stalledSearchTimer","setTimeout","_store$getState","store","getState","partialState","resultsFacetValues","isSearchStalled","handleSearchSuccess","handleSearchError","skip","initialSearchParameters","widgetsManager","metadata","getMetadata","searching","transporter","_cacheHydrated","_useCache","baseMethod","requests","_len2","methodArgs","_key2","requestsWithSerializedParams","request","responsesCache","method","acc","result","rawResults","cache","hydrateSearchClientWithMultiIndexRequest","hydrateSearchClientWithSingleIndexRequest","hydrateSearchClient","nextState","subscribe","createStore","hydrateMetadata","_internalIndexId","a","hydrateResultsState","searchingForFacetValues","getSearchParameters","sharedParameters","res","mainParameters","targetedIndexEqualMainIndex","subIndexEqualMainIndex","sort","derivedIndices","targetedIndexNotEqualMainIndex","subIndexNotEqualMainIndex","derivedParameters","_getSearchParameters","detach","isDerivedHelpersEmpty","getFacetByName","currentState","nextIsSearchStalled","clearTimeout","getWidgetsIds","meta","onSearchForFacetValues","_ref5","_ref5$maxFacetHits","maxFacetHitsWithinRange","Math","max","min","_objectSpread7","onExternalStateUpdate","nextSearchState","transitionState","updateClient","updateIndex","newIndex","skipSearch","datum","items","nestedItem","_createContext","onInternalStateUpdate","createHrefForState","onSearchStateChange","onSearchParameters","InstantSearchConsumer","Consumer","InstantSearchProvider","Provider","_createContext2","IndexConsumer","IndexProvider","isControlled","_Component","InstantSearch","_this","instantSearchManager","onWidgetsInternalStateUpdate","nextProps","prevState","nextIsControlled","previousSearchState","prevProps","prevIsControlled","refresh","isUnmounting","createURL","getKnownKeys","_searchState","widgetsCollector","_searchState2","children","string","isRequired","shape","func","bool","oneOfType","array","node","number","_extends","assign","createConnector","connectorDesc","Composed","Connector","isWidget","Component","providedProps","getProvidedProps","refine","_len3","_key3","_this2","unsubscribe","unregisterWidget","shouldComponentUpdate","propsEqual","cleanUp","_this$props$contextVa","searchParameters","nextWidgetsState","prevWidgetsState","_this$props","refineProps","searchForFacetValuesProps","searchForItems","propTypes","createConnectorWithoutContext","prevSearchState","propKeys","nonPresentKeys","_props","prop","subState","configureState","getCurrentRefinement","_refine","connectSearchBox","_cleanUp","label","onFocus","hasFocus","placeholder","aria-label","height","width","allSearchResults","_ref$preTag","_ref$postTag","highlight","hostname","location","url","queryID","__queryID","addQueryID","__position","getIndexContext","Index","indexContext","inferredIndexId","AlgoliaLogo","xmlns","baseProfile","x1","x2","y1","y2","gradientUnits","gradientTransform","offset","stopColor","HitCount","connectStateResults","hitCount","nbHits","CustomHighlight","connectHighlight","parsedHit","part","CustomPoweredBy","connectPoweredBy","href","rel","CustomHits","connectHits","objectID","to","SearchResult","show","ref","onClickOutside","onClick","element","contains","useEffect","addEventListener","removeEventListener","Search","rootRef","createRef","useState","setFocus","algoliasearch","process","useClickOutside","Configure","restrictSearchableAttributes","searchIndices","title","Header","siteTitle","defaultLang","site","siteMetadata","Layout","data","sortBy","defaults","defaultInstructions","out","sortInstruction","matchingDefault","defaultInstruction","t","getOwnPropertyDescriptors","defineProperties","u","next","done","return","from","localStorage","parse","getItem","miss","all","setItem","delete","clear","removeItem","caches","serializable","c","floor","random","h","entries","timeout","headers","queryParameters","cacheable","Read","Write","Any","g","status","lastUpdate","Date","now","b","protocol","accept","P","j","toLowerCase","userAgent","transporterStackTrace","A","S","connectTimeout","timeouts","connect","responseTimeout","response","host","triesLeft","onSucess","onRetry","isTimedOut","logger","info","x","hostsCache","onFail","requester","send","getTimeout","statelessHosts","reverse","add","segment","T","charAt","substr","N","appId","authMode","apiKey","requestsCache","hosts","read","mappedRequestOptions","write","methods","C","k","J","F","E","queryLanguages","I","H","XMLHttpRequest","open","setRequestHeader","abort","onreadystatechange","readyState","OPENED","onerror","responseText","onload","debug","multipleQueries","multipleSearchForFacetValues","findAnswers","isObjectOrArrayOrFunction","_merge","sourceVal","targetVal","comparator","defaultsPure","lib","addRefinement","refinementList","valueAsString","facetRefinement","mod","removeRefinement","clearRefinement","refinementType","hasChanged","newRefinementList","memo","facetList","refinementValue","containsRefinements","refinementValueAsString","mainHelper","main","algoliasearchHelper","ctor","superCtor","intersection","valToNumber","isValidUserToken","RefinementList","isEqualNumericRefinement","every","el","newParameters","_parseNumbers","userToken","paramName","isKeyKnown","PARAMETERS","isValueDefined","numbers","parsedValue","parseFloat","insideBoundingBox","geoRect","parsedValues","vPrime","toggleHierarchicalFacetRefinement","validate","patch","_clearNumericRefinements","newQuery","newPage","setFacets","setDisjunctiveFacets","setHitsPerPage","setTypoTolerance","typoTolerance","isNumericRefined","paramValue","op","val","newNumericRefinements","operatorList","outValues","addFacet","addDisjunctiveFacet","addHierarchicalFacet","modification","removeFacet","removeDisjunctiveFacet","removeHierarchicalFacet","toggleConjunctiveFacetRefinement","toggleDisjunctiveFacetRefinement","isOperatorDefined","searchedValue","isAttributeValueDefined","currentValue","disjunctiveNumericRefinedFacets","getUnrefinedDisjunctiveFacets","refinedFacets","managedParameters","queryParams","nextWithNumbers","previousPlainObject","nextPlainObject","previous","isPreviousValueDefined","isNextValueDefined","_getHierarchicalFacetSortBy","_getHierarchicalShowParentLevel","showParentLevel","hierarchicalFacetName","refinement","trim","arr1","arr2","test","hasElementType","Element","hasMap","Map","hasSet","Set","hasArrayBuffer","ArrayBuffer","isView","equal","it","size","has","RegExp","flags","valueOf","$$typeof","sources","hierarchicalFacetResult","hierarchicalFacetIndex","hierarchicalFacetRefinement","hierarchicalSeparator","hierarchicalRootPath","hierarchicalShowParentLevel","prepareHierarchicalFacetSortBy","rootExhaustive","facetResult","exhaustive","generateTreeFn","hierarchicalTree","currentHierarchicalLevel","parent","subtree","picked","tuple","parentPath","onlyMatchingTree","orderBy","facetCount","generateHierarchicalTree","clock","_class","_temp","ATTRIBUTE_NAMES","TAG_NAMES","BASE","BODY","HEAD","HTML","LINK","META","NOSCRIPT","SCRIPT","STYLE","TITLE","TAG_PROPERTIES","REACT_TAG_MAP","accesskey","charset","class","contenteditable","contextmenu","itemprop","tabindex","HELMET_PROPS","HTML_TAG_MAP","SELF_CLOSING_TAGS","classCallCheck","createClass","objectWithoutProperties","possibleConstructorReturn","encodeSpecialCharacters","str","getTitleFromPropsList","propsList","innermostTitle","getInnermostProperty","innermostTemplate","innermostDefaultTitle","getOnChangeClientState","getAttributesFromPropsList","tagType","tagAttrs","getBaseTagFromPropsList","primaryAttributes","innermostBaseTag","lowerCaseAttributeKey","getTagsFromPropsList","tagName","approvedSeenTags","approvedTags","instanceTags","instanceSeenTags","primaryAttributeKey","attributeKey","tagUnion","property","rafPolyfill","callback","currentTime","cafPolyfill","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","global","cancelAnimationFrame","webkitCancelAnimationFrame","mozCancelAnimationFrame","msg","_helmetCallback","commitTagChanges","baseTag","bodyAttributes","htmlAttributes","linkTags","metaTags","noscriptTags","onChangeClientState","scriptTags","styleTags","titleAttributes","updateAttributes","updateTitle","tagUpdates","updateTags","addedTags","removedTags","_tagUpdates$tagType","newTags","oldTags","flattenArray","possibleArray","elementTag","getElementsByTagName","helmetAttributeString","getAttribute","helmetAttributes","attributesToRemove","attributeKeys","setAttribute","indexToSave","_i","removeAttribute","tags","headElement","head","querySelector","tagNodes","querySelectorAll","indexToDelete","newElement","innerHTML","styleSheet","cssText","appendChild","createTextNode","some","existingTag","isEqualNode","parentNode","removeChild","generateElementAttributesAsString","attr","convertElementAttributestoReactProps","initProps","getMethodsForTag","toComponent","_initProps","attributeString","flattenedTitle","generateTitleAsString","_mappedTag","mappedTag","mappedAttribute","dangerouslySetInnerHTML","__html","generateTagsAsReactComponent","attributeHtml","tagContent","isSelfClosing","generateTagsAsString","_ref$title","base","link","noscript","script","style","HelmetSideEffects","defer","HelmetExport","_React$Component","HelmetWrapper","mapNestedChildrenToProps","child","nestedChildren","flattenArrayTypeChildren","_babelHelpers$extends","arrayTypeChildren","newChildProps","mapObjectTypeChildren","_babelHelpers$extends2","_babelHelpers$extends3","newProps","mapArrayTypeChildrenToProps","newFlattenedProps","arrayChildName","_babelHelpers$extends4","warnOnInvalidChildren","mapChildrenToProps","Children","_child$props","initAttributes","convertReactPropstoHtmlAttributes","arrayOf","defaultTitle","titleTemplate","mappedState","renderStatic","compact","findIndex","formatSort","getIndices","idx","assignFacetStats","dest","facetStats","stats","mainSubResponse","_rawResults","processingTimeMS","sum","facetsIndices","disjunctiveFacetsIndices","nextDisjunctiveResult","mainFacets","facetKey","hierarchicalAttributeName","facetValueObject","facetIndex","idxAttributeName","exhaustiveFacetsCount","isFacetDisjunctive","isFacetConjunctive","facets_stats","disjunctiveFacet","dfacet","facetResults","dataFromMainRequest","defaultData","root","excludes","_state","recSort","sortFn","childNode","sortedChildren","getFacetStatsIfAvailable","getRefinement","resultsFacets","predicate","DEFAULT_SORT","getFacetValues","extractNormalizedFacetValues","order","hierarchicalFacetValues","vanillaSortFn","getFacetStats","facetDeclaration","rootFacet","intermediateFacet","newFacet","numericValue","SEO","description","metaDescription","author","compareAscending","other","valIsDefined","valIsNull","othIsDefined","othIsNull","collection","iteratees","orders","criteria","iteratee"],"mappings":"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","file":"commons-d5fa543038761f87efe2.js","sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null;\nvar ReflectApply = R && typeof R.apply === 'function' ? R.apply : function ReflectApply(target, receiver, args) {\n  return Function.prototype.apply.call(target, receiver, args);\n};\nvar ReflectOwnKeys;\n\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys;\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n};\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\n\nmodule.exports = EventEmitter;\nmodule.exports.once = once; // Backwards-compat with node 0.10.x\n\nEventEmitter.EventEmitter = EventEmitter;\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined; // By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\n\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function get() {\n    return defaultMaxListeners;\n  },\n  set: function set(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function () {\n  if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n}; // Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\n\n\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined) return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n\n  for (var i = 1; i < arguments.length; i++) {\n    args.push(arguments[i]);\n  }\n\n  var doError = type === 'error';\n  var events = this._events;\n  if (events !== undefined) doError = doError && events.error === undefined;else if (!doError) return false; // If there is no 'error' event listener then throw.\n\n  if (doError) {\n    var er;\n    if (args.length > 0) er = args[0];\n\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    } // At least give some kind of context to the user\n\n\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n  if (handler === undefined) return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n\n    for (var i = 0; i < len; ++i) {\n      ReflectApply(listeners[i], this, args);\n    }\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n  checkListener(listener);\n  events = target._events;\n\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type, listener.listener ? listener.listener : listener); // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n\n      events = target._events;\n    }\n\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] = prepend ? [listener, existing] : [existing, listener]; // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    } // Check for listener leak\n\n\n    m = _getMaxListeners(target);\n\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true; // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n\n      var w = new Error('Possible EventEmitter memory leak detected. ' + existing.length + ' ' + String(type) + ' listeners ' + 'added. Use emitter.setMaxListeners() to ' + 'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener = function prependListener(type, listener) {\n  return _addListener(this, type, listener, true);\n};\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0) return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = {\n    fired: false,\n    wrapFn: undefined,\n    target: target,\n    type: type,\n    listener: listener\n  };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {\n  checkListener(listener);\n  this.prependListener(type, _onceWrap(this, type, listener));\n  return this;\n}; // Emits a 'removeListener' event if and only if the listener was removed.\n\n\nEventEmitter.prototype.removeListener = function removeListener(type, listener) {\n  var list, events, position, i, originalListener;\n  checkListener(listener);\n  events = this._events;\n  if (events === undefined) return this;\n  list = events[type];\n  if (list === undefined) return this;\n\n  if (list === listener || list.listener === listener) {\n    if (--this._eventsCount === 0) this._events = Object.create(null);else {\n      delete events[type];\n      if (events.removeListener) this.emit('removeListener', type, list.listener || listener);\n    }\n  } else if (typeof list !== 'function') {\n    position = -1;\n\n    for (i = list.length - 1; i >= 0; i--) {\n      if (list[i] === listener || list[i].listener === listener) {\n        originalListener = list[i].listener;\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0) return this;\n    if (position === 0) list.shift();else {\n      spliceOne(list, position);\n    }\n    if (list.length === 1) events[type] = list[0];\n    if (events.removeListener !== undefined) this.emit('removeListener', type, originalListener || listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {\n  var listeners, events, i;\n  events = this._events;\n  if (events === undefined) return this; // not listening for removeListener, no need to emit\n\n  if (events.removeListener === undefined) {\n    if (arguments.length === 0) {\n      this._events = Object.create(null);\n      this._eventsCount = 0;\n    } else if (events[type] !== undefined) {\n      if (--this._eventsCount === 0) this._events = Object.create(null);else delete events[type];\n    }\n\n    return this;\n  } // emit removeListener for all listeners on all events\n\n\n  if (arguments.length === 0) {\n    var keys = Object.keys(events);\n    var key;\n\n    for (i = 0; i < keys.length; ++i) {\n      key = keys[i];\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n\n    this.removeAllListeners('removeListener');\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n    return this;\n  }\n\n  listeners = events[type];\n\n  if (typeof listeners === 'function') {\n    this.removeListener(type, listeners);\n  } else if (listeners !== undefined) {\n    // LIFO order\n    for (i = listeners.length - 1; i >= 0; i--) {\n      this.removeListener(type, listeners[i]);\n    }\n  }\n\n  return this;\n};\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n  if (events === undefined) return [];\n  var evlistener = events[type];\n  if (evlistener === undefined) return [];\n  if (typeof evlistener === 'function') return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function (emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\n\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n\n  for (var i = 0; i < n; ++i) {\n    copy[i] = arr[i];\n  }\n\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++) {\n    list[index] = list[index + 1];\n  }\n\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function eventListener() {\n      if (errorListener !== undefined) {\n        emitter.removeListener('error', errorListener);\n      }\n\n      resolve([].slice.call(arguments));\n    }\n\n    ;\n    var errorListener; // Adding an error listener is not optional because\n    // if an error is thrown on an event emitter we cannot\n    // guarantee that the actual event we are waiting will\n    // be fired. The result could be a silent way to create\n    // memory or file descriptor leaks, which is something\n    // we should avoid.\n\n    if (name !== 'error') {\n      errorListener = function errorListener(err) {\n        emitter.removeListener(name, eventListener);\n        reject(err);\n      };\n\n      emitter.once('error', errorListener);\n    }\n\n    emitter.once(name, eventListener);\n  });\n}","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar merge = require('./functions/merge');\n\nvar requestBuilder = {\n  /**\n   * Get all the queries to send to the client, those queries can used directly\n   * with the Algolia client.\n   * @private\n   * @return {object[]} The queries\n   */\n  _getQueries: function getQueries(index, state) {\n    var queries = []; // One query for the hits\n\n    queries.push({\n      indexName: index,\n      params: requestBuilder._getHitsSearchParams(state)\n    }); // One for each disjunctive facets\n\n    state.getRefinedDisjunctiveFacets().forEach(function (refinedFacet) {\n      queries.push({\n        indexName: index,\n        params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet)\n      });\n    }); // maybe more to get the root level of hierarchical facets when activated\n\n    state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {\n      var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n      var currentRefinement = state.getHierarchicalRefinement(refinedFacet); // if we are deeper than level 0 (starting from `beer > IPA`)\n      // we want to get the root values\n\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n      if (currentRefinement.length > 0 && currentRefinement[0].split(separator).length > 1) {\n        queries.push({\n          indexName: index,\n          params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet, true)\n        });\n      }\n    });\n    return queries;\n  },\n\n  /**\n   * Build search parameters used to fetch hits\n   * @private\n   * @return {object.<string, any>}\n   */\n  _getHitsSearchParams: function _getHitsSearchParams(state) {\n    var facets = state.facets.concat(state.disjunctiveFacets).concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state));\n\n    var facetFilters = requestBuilder._getFacetFilters(state);\n\n    var numericFilters = requestBuilder._getNumericFilters(state);\n\n    var tagFilters = requestBuilder._getTagFilters(state);\n\n    var additionalParams = {\n      facets: facets,\n      tagFilters: tagFilters\n    };\n\n    if (facetFilters.length > 0) {\n      additionalParams.facetFilters = facetFilters;\n    }\n\n    if (numericFilters.length > 0) {\n      additionalParams.numericFilters = numericFilters;\n    }\n\n    return merge({}, state.getQueryParams(), additionalParams);\n  },\n\n  /**\n   * Build search parameters used to fetch a disjunctive facet\n   * @private\n   * @param  {string} facet the associated facet name\n   * @param  {boolean} hierarchicalRootLevel ?? FIXME\n   * @return {object}\n   */\n  _getDisjunctiveFacetSearchParams: function _getDisjunctiveFacetSearchParams(state, facet, hierarchicalRootLevel) {\n    var facetFilters = requestBuilder._getFacetFilters(state, facet, hierarchicalRootLevel);\n\n    var numericFilters = requestBuilder._getNumericFilters(state, facet);\n\n    var tagFilters = requestBuilder._getTagFilters(state);\n\n    var additionalParams = {\n      hitsPerPage: 1,\n      page: 0,\n      attributesToRetrieve: [],\n      attributesToHighlight: [],\n      attributesToSnippet: [],\n      tagFilters: tagFilters,\n      analytics: false,\n      clickAnalytics: false\n    };\n    var hierarchicalFacet = state.getHierarchicalFacetByName(facet);\n\n    if (hierarchicalFacet) {\n      additionalParams.facets = requestBuilder._getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, hierarchicalRootLevel);\n    } else {\n      additionalParams.facets = facet;\n    }\n\n    if (numericFilters.length > 0) {\n      additionalParams.numericFilters = numericFilters;\n    }\n\n    if (facetFilters.length > 0) {\n      additionalParams.facetFilters = facetFilters;\n    }\n\n    return merge({}, state.getQueryParams(), additionalParams);\n  },\n\n  /**\n   * Return the numeric filters in an algolia request fashion\n   * @private\n   * @param {string} [facetName] the name of the attribute for which the filters should be excluded\n   * @return {string[]} the numeric filters in the algolia format\n   */\n  _getNumericFilters: function _getNumericFilters(state, facetName) {\n    if (state.numericFilters) {\n      return state.numericFilters;\n    }\n\n    var numericFilters = [];\n    Object.keys(state.numericRefinements).forEach(function (attribute) {\n      var operators = state.numericRefinements[attribute] || {};\n      Object.keys(operators).forEach(function (operator) {\n        var values = operators[operator] || [];\n\n        if (facetName !== attribute) {\n          values.forEach(function (value) {\n            if (Array.isArray(value)) {\n              var vs = value.map(function (v) {\n                return attribute + operator + v;\n              });\n              numericFilters.push(vs);\n            } else {\n              numericFilters.push(attribute + operator + value);\n            }\n          });\n        }\n      });\n    });\n    return numericFilters;\n  },\n\n  /**\n   * Return the tags filters depending\n   * @private\n   * @return {string}\n   */\n  _getTagFilters: function _getTagFilters(state) {\n    if (state.tagFilters) {\n      return state.tagFilters;\n    }\n\n    return state.tagRefinements.join(',');\n  },\n\n  /**\n   * Build facetFilters parameter based on current refinements. The array returned\n   * contains strings representing the facet filters in the algolia format.\n   * @private\n   * @param  {string} [facet] if set, the current disjunctive facet\n   * @return {array.<string>}\n   */\n  _getFacetFilters: function _getFacetFilters(state, facet, hierarchicalRootLevel) {\n    var facetFilters = [];\n    var facetsRefinements = state.facetsRefinements || {};\n    Object.keys(facetsRefinements).forEach(function (facetName) {\n      var facetValues = facetsRefinements[facetName] || [];\n      facetValues.forEach(function (facetValue) {\n        facetFilters.push(facetName + ':' + facetValue);\n      });\n    });\n    var facetsExcludes = state.facetsExcludes || {};\n    Object.keys(facetsExcludes).forEach(function (facetName) {\n      var facetValues = facetsExcludes[facetName] || [];\n      facetValues.forEach(function (facetValue) {\n        facetFilters.push(facetName + ':-' + facetValue);\n      });\n    });\n    var disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements || {};\n    Object.keys(disjunctiveFacetsRefinements).forEach(function (facetName) {\n      var facetValues = disjunctiveFacetsRefinements[facetName] || [];\n\n      if (facetName === facet || !facetValues || facetValues.length === 0) {\n        return;\n      }\n\n      var orFilters = [];\n      facetValues.forEach(function (facetValue) {\n        orFilters.push(facetName + ':' + facetValue);\n      });\n      facetFilters.push(orFilters);\n    });\n    var hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements || {};\n    Object.keys(hierarchicalFacetsRefinements).forEach(function (facetName) {\n      var facetValues = hierarchicalFacetsRefinements[facetName] || [];\n      var facetValue = facetValues[0];\n\n      if (facetValue === undefined) {\n        return;\n      }\n\n      var hierarchicalFacet = state.getHierarchicalFacetByName(facetName);\n\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n      var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n\n      var attributeToRefine;\n      var attributesIndex; // we ask for parent facet values only when the `facet` is the current hierarchical facet\n\n      if (facet === facetName) {\n        // if we are at the root level already, no need to ask for facet values, we get them from\n        // the hits query\n        if (facetValue.indexOf(separator) === -1 || !rootPath && hierarchicalRootLevel === true || rootPath && rootPath.split(separator).length === facetValue.split(separator).length) {\n          return;\n        }\n\n        if (!rootPath) {\n          attributesIndex = facetValue.split(separator).length - 2;\n          facetValue = facetValue.slice(0, facetValue.lastIndexOf(separator));\n        } else {\n          attributesIndex = rootPath.split(separator).length - 1;\n          facetValue = rootPath;\n        }\n\n        attributeToRefine = hierarchicalFacet.attributes[attributesIndex];\n      } else {\n        attributesIndex = facetValue.split(separator).length - 1;\n        attributeToRefine = hierarchicalFacet.attributes[attributesIndex];\n      }\n\n      if (attributeToRefine) {\n        facetFilters.push([attributeToRefine + ':' + facetValue]);\n      }\n    });\n    return facetFilters;\n  },\n  _getHitsHierarchicalFacetsAttributes: function _getHitsHierarchicalFacetsAttributes(state) {\n    var out = [];\n    return state.hierarchicalFacets.reduce( // ask for as much levels as there's hierarchical refinements\n    function getHitsAttributesForHierarchicalFacet(allAttributes, hierarchicalFacet) {\n      var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0]; // if no refinement, ask for root level\n\n      if (!hierarchicalRefinement) {\n        allAttributes.push(hierarchicalFacet.attributes[0]);\n        return allAttributes;\n      }\n\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n      var level = hierarchicalRefinement.split(separator).length;\n      var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);\n      return allAttributes.concat(newAttributes);\n    }, out);\n  },\n  _getDisjunctiveHierarchicalFacetAttribute: function _getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, rootLevel) {\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n    if (rootLevel === true) {\n      var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n\n      var attributeIndex = 0;\n\n      if (rootPath) {\n        attributeIndex = rootPath.split(separator).length;\n      }\n\n      return [hierarchicalFacet.attributes[attributeIndex]];\n    }\n\n    var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || ''; // if refinement is 'beers > IPA > Flying dog',\n    // then we want `facets: ['beers > IPA']` as disjunctive facet (parent level values)\n\n    var parentLevel = hierarchicalRefinement.split(separator).length - 1;\n    return hierarchicalFacet.attributes.slice(0, parentLevel + 1);\n  },\n  getSearchForFacetQuery: function getSearchForFacetQuery(facetName, query, maxFacetHits, state) {\n    var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ? state.clearRefinements(facetName) : state;\n    var searchForFacetSearchParameters = {\n      facetQuery: query,\n      facetName: facetName\n    };\n\n    if (typeof maxFacetHits === 'number') {\n      searchForFacetSearchParameters.maxFacetHits = maxFacetHits;\n    }\n\n    return merge({}, requestBuilder._getHitsSearchParams(stateForSearchForFacetValues), searchForFacetSearchParameters);\n  }\n};\nmodule.exports = requestBuilder;","'use strict';\n\nmodule.exports = '3.3.4';","'use strict';\n\nvar SearchParameters = require('./SearchParameters');\n\nvar SearchResults = require('./SearchResults');\n\nvar DerivedHelper = require('./DerivedHelper');\n\nvar requestBuilder = require('./requestBuilder');\n\nvar events = require('events');\n\nvar inherits = require('./functions/inherits');\n\nvar objectHasKeys = require('./functions/objectHasKeys');\n\nvar version = require('./version');\n/**\n * Event triggered when a parameter is set or updated\n * @event AlgoliaSearchHelper#event:change\n * @property {object} event\n * @property {SearchParameters} event.state the current parameters with the latest changes applied\n * @property {SearchResults} event.results the previous results received from Algolia. `null` before the first request\n * @example\n * helper.on('change', function(event) {\n *   console.log('The parameters have changed');\n * });\n */\n\n/**\n * Event triggered when a main search is sent to Algolia\n * @event AlgoliaSearchHelper#event:search\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search\n * @property {SearchResults} event.results the results from the previous search. `null` if it is the first search.\n * @example\n * helper.on('search', function(event) {\n *   console.log('Search sent');\n * });\n */\n\n/**\n * Event triggered when a search using `searchForFacetValues` is sent to Algolia\n * @event AlgoliaSearchHelper#event:searchForFacetValues\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search it is the first search.\n * @property {string} event.facet the facet searched into\n * @property {string} event.query the query used to search in the facets\n * @example\n * helper.on('searchForFacetValues', function(event) {\n *   console.log('searchForFacetValues sent');\n * });\n */\n\n/**\n * Event triggered when a search using `searchOnce` is sent to Algolia\n * @event AlgoliaSearchHelper#event:searchOnce\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search it is the first search.\n * @example\n * helper.on('searchOnce', function(event) {\n *   console.log('searchOnce sent');\n * });\n */\n\n/**\n * Event triggered when the results are retrieved from Algolia\n * @event AlgoliaSearchHelper#event:result\n * @property {object} event\n * @property {SearchResults} event.results the results received from Algolia\n * @property {SearchParameters} event.state the parameters used to query Algolia. Those might be different from the one in the helper instance (for example if the network is unreliable).\n * @example\n * helper.on('result', function(event) {\n *   console.log('Search results received');\n * });\n */\n\n/**\n * Event triggered when Algolia sends back an error. For example, if an unknown parameter is\n * used, the error can be caught using this event.\n * @event AlgoliaSearchHelper#event:error\n * @property {object} event\n * @property {Error} event.error the error returned by the Algolia.\n * @example\n * helper.on('error', function(event) {\n *   console.log('Houston we got a problem.');\n * });\n */\n\n/**\n * Event triggered when the queue of queries have been depleted (with any result or outdated queries)\n * @event AlgoliaSearchHelper#event:searchQueueEmpty\n * @example\n * helper.on('searchQueueEmpty', function() {\n *   console.log('No more search pending');\n *   // This is received before the result event if we're not expecting new results\n * });\n *\n * helper.search();\n */\n\n/**\n * Initialize a new AlgoliaSearchHelper\n * @class\n * @classdesc The AlgoliaSearchHelper is a class that ease the management of the\n * search. It provides an event based interface for search callbacks:\n *  - change: when the internal search state is changed.\n *    This event contains a {@link SearchParameters} object and the\n *    {@link SearchResults} of the last result if any.\n *  - search: when a search is triggered using the `search()` method.\n *  - result: when the response is retrieved from Algolia and is processed.\n *    This event contains a {@link SearchResults} object and the\n *    {@link SearchParameters} corresponding to this answer.\n *  - error: when the response is an error. This event contains the error returned by the server.\n * @param  {AlgoliaSearch} client an AlgoliaSearch client\n * @param  {string} index the index name to query\n * @param  {SearchParameters | object} options an object defining the initial\n * config of the search. It doesn't have to be a {SearchParameters},\n * just an object containing the properties you need from it.\n */\n\n\nfunction AlgoliaSearchHelper(client, index, options) {\n  if (typeof client.addAlgoliaAgent === 'function') {\n    client.addAlgoliaAgent('JS Helper (' + version + ')');\n  }\n\n  this.setClient(client);\n  var opts = options || {};\n  opts.index = index;\n  this.state = SearchParameters.make(opts);\n  this.lastResults = null;\n  this._queryId = 0;\n  this._lastQueryIdReceived = -1;\n  this.derivedHelpers = [];\n  this._currentNbQueries = 0;\n}\n\ninherits(AlgoliaSearchHelper, events.EventEmitter);\n/**\n * Start the search with the parameters set in the state. When the\n * method is called, it triggers a `search` event. The results will\n * be available through the `result` event. If an error occurs, an\n * `error` will be fired instead.\n * @return {AlgoliaSearchHelper}\n * @fires search\n * @fires result\n * @fires error\n * @chainable\n */\n\nAlgoliaSearchHelper.prototype.search = function () {\n  this._search({\n    onlyWithDerivedHelpers: false\n  });\n\n  return this;\n};\n\nAlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function () {\n  this._search({\n    onlyWithDerivedHelpers: true\n  });\n\n  return this;\n};\n/**\n * Gets the search query parameters that would be sent to the Algolia Client\n * for the hits\n * @return {object} Query Parameters\n */\n\n\nAlgoliaSearchHelper.prototype.getQuery = function () {\n  var state = this.state;\n  return requestBuilder._getHitsSearchParams(state);\n};\n/**\n * Start a search using a modified version of the current state. This method does\n * not trigger the helper lifecycle and does not modify the state kept internally\n * by the helper. This second aspect means that the next search call will be the\n * same as a search call before calling searchOnce.\n * @param {object} options can contain all the parameters that can be set to SearchParameters\n * plus the index\n * @param {function} [callback] optional callback executed when the response from the\n * server is back.\n * @return {promise|undefined} if a callback is passed the method returns undefined\n * otherwise it returns a promise containing an object with two keys :\n *  - content with a SearchResults\n *  - state with the state used for the query as a SearchParameters\n * @example\n * // Changing the number of records returned per page to 1\n * // This example uses the callback API\n * var state = helper.searchOnce({hitsPerPage: 1},\n *   function(error, content, state) {\n *     // if an error occurred it will be passed in error, otherwise its value is null\n *     // content contains the results formatted as a SearchResults\n *     // state is the instance of SearchParameters used for this search\n *   });\n * @example\n * // Changing the number of records returned per page to 1\n * // This example uses the promise API\n * var state1 = helper.searchOnce({hitsPerPage: 1})\n *                 .then(promiseHandler);\n *\n * function promiseHandler(res) {\n *   // res contains\n *   // {\n *   //   content : SearchResults\n *   //   state   : SearchParameters (the one used for this specific search)\n *   // }\n * }\n */\n\n\nAlgoliaSearchHelper.prototype.searchOnce = function (options, cb) {\n  var tempState = !options ? this.state : this.state.setQueryParameters(options);\n\n  var queries = requestBuilder._getQueries(tempState.index, tempState);\n\n  var self = this;\n  this._currentNbQueries++;\n  this.emit('searchOnce', {\n    state: tempState\n  });\n\n  if (cb) {\n    this.client.search(queries).then(function (content) {\n      self._currentNbQueries--;\n\n      if (self._currentNbQueries === 0) {\n        self.emit('searchQueueEmpty');\n      }\n\n      cb(null, new SearchResults(tempState, content.results), tempState);\n    }).catch(function (err) {\n      self._currentNbQueries--;\n\n      if (self._currentNbQueries === 0) {\n        self.emit('searchQueueEmpty');\n      }\n\n      cb(err, null, tempState);\n    });\n    return undefined;\n  }\n\n  return this.client.search(queries).then(function (content) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    return {\n      content: new SearchResults(tempState, content.results),\n      state: tempState,\n      _originalResponse: content\n    };\n  }, function (e) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    throw e;\n  });\n};\n/**\n * Structure of each result when using\n * [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)\n * @typedef FacetSearchHit\n * @type {object}\n * @property {string} value the facet value\n * @property {string} highlighted the facet value highlighted with the query string\n * @property {number} count number of occurrence of this facet value\n * @property {boolean} isRefined true if the value is already refined\n */\n\n/**\n * Structure of the data resolved by the\n * [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)\n * promise.\n * @typedef FacetSearchResult\n * @type {object}\n * @property {FacetSearchHit} facetHits the results for this search for facet values\n * @property {number} processingTimeMS time taken by the query inside the engine\n */\n\n/**\n * Search for facet values based on an query and the name of a faceted attribute. This\n * triggers a search and will return a promise. On top of using the query, it also sends\n * the parameters from the state so that the search is narrowed down to only the possible values.\n *\n * See the description of [FacetSearchResult](reference.html#FacetSearchResult)\n * @param {string} facet the name of the faceted attribute\n * @param {string} query the string query for the search\n * @param {number} [maxFacetHits] the maximum number values returned. Should be > 0 and <= 100\n * @param {object} [userState] the set of custom parameters to use on top of the current state. Setting a property to `undefined` removes\n * it in the generated query.\n * @return {promise.<FacetSearchResult>} the results of the search\n */\n\n\nAlgoliaSearchHelper.prototype.searchForFacetValues = function (facet, query, maxFacetHits, userState) {\n  var clientHasSFFV = typeof this.client.searchForFacetValues === 'function';\n\n  if (!clientHasSFFV && typeof this.client.initIndex !== 'function') {\n    throw new Error('search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues or client.initIndex(index).searchForFacetValues');\n  }\n\n  var state = this.state.setQueryParameters(userState || {});\n  var isDisjunctive = state.isDisjunctiveFacet(facet);\n  var algoliaQuery = requestBuilder.getSearchForFacetQuery(facet, query, maxFacetHits, state);\n  this._currentNbQueries++;\n  var self = this;\n  this.emit('searchForFacetValues', {\n    state: state,\n    facet: facet,\n    query: query\n  });\n  var searchForFacetValuesPromise = clientHasSFFV ? this.client.searchForFacetValues([{\n    indexName: state.index,\n    params: algoliaQuery\n  }]) : this.client.initIndex(state.index).searchForFacetValues(algoliaQuery);\n  return searchForFacetValuesPromise.then(function addIsRefined(content) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    content = Array.isArray(content) ? content[0] : content;\n    content.facetHits.forEach(function (f) {\n      f.isRefined = isDisjunctive ? state.isDisjunctiveFacetRefined(facet, f.value) : state.isFacetRefined(facet, f.value);\n    });\n    return content;\n  }, function (e) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    throw e;\n  });\n};\n/**\n * Sets the text query used for the search.\n *\n * This method resets the current page to 0.\n * @param  {string} q the user query\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.setQuery = function (q) {\n  this._change({\n    state: this.state.resetPage().setQuery(q),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Remove all the types of refinements except tags. A string can be provided to remove\n * only the refinements of a specific attribute. For more advanced use case, you can\n * provide a function instead. This function should follow the\n * [clearCallback definition](#SearchParameters.clearCallback).\n *\n * This method resets the current page to 0.\n * @param {string} [name] optional name of the facet / attribute on which we want to remove all refinements\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n * @example\n * // Removing all the refinements\n * helper.clearRefinements().search();\n * @example\n * // Removing all the filters on a the category attribute.\n * helper.clearRefinements('category').search();\n * @example\n * // Removing only the exclude filters on the category facet.\n * helper.clearRefinements(function(value, attribute, type) {\n *   return type === 'exclude' && attribute === 'category';\n * }).search();\n */\n\n\nAlgoliaSearchHelper.prototype.clearRefinements = function (name) {\n  this._change({\n    state: this.state.resetPage().clearRefinements(name),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Remove all the tag filters.\n *\n * This method resets the current page to 0.\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.clearTags = function () {\n  this._change({\n    state: this.state.resetPage().clearTags(),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Adds a disjunctive filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addDisjunctiveFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addDisjunctiveFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.addDisjunctiveRefine = function () {\n  return this.addDisjunctiveFacetRefinement.apply(this, arguments);\n};\n/**\n * Adds a refinement on a hierarchical facet. It will throw\n * an exception if the facet is not defined or if the facet\n * is already refined.\n *\n * This method resets the current page to 0.\n * @param {string} facet the facet name\n * @param {string} path the hierarchical facet path\n * @return {AlgoliaSearchHelper}\n * @throws Error if the facet is not defined or if the facet is refined\n * @chainable\n * @fires change\n */\n\n\nAlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addHierarchicalFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Adds a an numeric filter to an attribute with the `operator` and `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} attribute the attribute on which the numeric filter applies\n * @param  {string} operator the operator of the filter\n * @param  {number} value the value of the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addNumericRefinement = function (attribute, operator, value) {\n  this._change({\n    state: this.state.resetPage().addNumericRefinement(attribute, operator, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Adds a filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.addRefine = function () {\n  return this.addFacetRefinement.apply(this, arguments);\n};\n/**\n * Adds a an exclusion filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addFacetExclusion = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addExcludeRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetExclusion}\n */\n\n\nAlgoliaSearchHelper.prototype.addExclude = function () {\n  return this.addFacetExclusion.apply(this, arguments);\n};\n/**\n * Adds a tag filter with the `tag` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param {string} tag the tag to add to the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addTag = function (tag) {\n  this._change({\n    state: this.state.resetPage().addTagRefinement(tag),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Removes an numeric filter to an attribute with the `operator` and `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * Some parameters are optional, triggering different behavior:\n *  - if the value is not provided, then all the numeric value will be removed for the\n *  specified attribute/operator couple.\n *  - if the operator is not provided either, then all the numeric filter on this attribute\n *  will be removed.\n *\n * This method resets the current page to 0.\n * @param  {string} attribute the attribute on which the numeric filter applies\n * @param  {string} [operator] the operator of the filter\n * @param  {number} [value] the value of the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeNumericRefinement = function (attribute, operator, value) {\n  this._change({\n    state: this.state.resetPage().removeNumericRefinement(attribute, operator, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Removes a disjunctive filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().removeDisjunctiveFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeDisjunctiveFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function () {\n  return this.removeDisjunctiveFacetRefinement.apply(this, arguments);\n};\n/**\n * Removes the refinement set on a hierarchical facet.\n * @param {string} facet the facet name\n * @return {AlgoliaSearchHelper}\n * @throws Error if the facet is not defined or if the facet is not refined\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function (facet) {\n  this._change({\n    state: this.state.resetPage().removeHierarchicalFacetRefinement(facet),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Removes a filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().removeFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.removeRefine = function () {\n  return this.removeFacetRefinement.apply(this, arguments);\n};\n/**\n * Removes an exclusion filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeFacetExclusion = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().removeExcludeRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetExclusion}\n */\n\n\nAlgoliaSearchHelper.prototype.removeExclude = function () {\n  return this.removeFacetExclusion.apply(this, arguments);\n};\n/**\n * Removes a tag filter with the `tag` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param {string} tag tag to remove from the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeTag = function (tag) {\n  this._change({\n    state: this.state.resetPage().removeTagRefinement(tag),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Adds or removes an exclusion filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.toggleFacetExclusion = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().toggleExcludeFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetExclusion}\n */\n\n\nAlgoliaSearchHelper.prototype.toggleExclude = function () {\n  return this.toggleFacetExclusion.apply(this, arguments);\n};\n/**\n * Adds or removes a filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method can be used for conjunctive, disjunctive and hierarchical filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper}\n * @throws Error will throw an error if the facet is not declared in the settings of the helper\n * @fires change\n * @chainable\n * @deprecated since version 2.19.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.toggleRefinement = function (facet, value) {\n  return this.toggleFacetRefinement(facet, value);\n};\n/**\n * Adds or removes a filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method can be used for conjunctive, disjunctive and hierarchical filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper}\n * @throws Error will throw an error if the facet is not declared in the settings of the helper\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.toggleFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().toggleFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.toggleRefine = function () {\n  return this.toggleFacetRefinement.apply(this, arguments);\n};\n/**\n * Adds or removes a tag filter with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method resets the current page to 0.\n * @param {string} tag tag to remove or add\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.toggleTag = function (tag) {\n  this._change({\n    state: this.state.resetPage().toggleTagRefinement(tag),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Increments the page number by one.\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n * @example\n * helper.setPage(0).nextPage().getPage();\n * // returns 1\n */\n\n\nAlgoliaSearchHelper.prototype.nextPage = function () {\n  var page = this.state.page || 0;\n  return this.setPage(page + 1);\n};\n/**\n * Decrements the page number by one.\n * @fires change\n * @return {AlgoliaSearchHelper}\n * @chainable\n * @example\n * helper.setPage(1).previousPage().getPage();\n * // returns 0\n */\n\n\nAlgoliaSearchHelper.prototype.previousPage = function () {\n  var page = this.state.page || 0;\n  return this.setPage(page - 1);\n};\n/**\n * @private\n */\n\n\nfunction setCurrentPage(page) {\n  if (page < 0) throw new Error('Page requested below 0.');\n\n  this._change({\n    state: this.state.setPage(page),\n    isPageReset: false\n  });\n\n  return this;\n}\n/**\n * Change the current page\n * @deprecated\n * @param  {number} page The page number\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.setCurrentPage = setCurrentPage;\n/**\n * Updates the current page.\n * @function\n * @param  {number} page The page number\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\nAlgoliaSearchHelper.prototype.setPage = setCurrentPage;\n/**\n * Updates the name of the index that will be targeted by the query.\n *\n * This method resets the current page to 0.\n * @param {string} name the index name\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\nAlgoliaSearchHelper.prototype.setIndex = function (name) {\n  this._change({\n    state: this.state.resetPage().setIndex(name),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Update a parameter of the search. This method reset the page\n *\n * The complete list of parameters is available on the\n * [Algolia website](https://www.algolia.com/doc/rest#query-an-index).\n * The most commonly used parameters have their own [shortcuts](#query-parameters-shortcuts)\n * or benefit from higher-level APIs (all the kind of filters and facets have their own API)\n *\n * This method resets the current page to 0.\n * @param {string} parameter name of the parameter to update\n * @param {any} value new value of the parameter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n * @example\n * helper.setQueryParameter('hitsPerPage', 20).search();\n */\n\n\nAlgoliaSearchHelper.prototype.setQueryParameter = function (parameter, value) {\n  this._change({\n    state: this.state.resetPage().setQueryParameter(parameter, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Set the whole state (warning: will erase previous state)\n * @param {SearchParameters} newState the whole new state\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.setState = function (newState) {\n  this._change({\n    state: SearchParameters.make(newState),\n    isPageReset: false\n  });\n\n  return this;\n};\n/**\n * Override the current state without triggering a change event.\n * Do not use this method unless you know what you are doing. (see the example\n * for a legit use case)\n * @param {SearchParameters} newState the whole new state\n * @return {AlgoliaSearchHelper}\n * @example\n *  helper.on('change', function(state){\n *    // In this function you might want to find a way to store the state in the url/history\n *    updateYourURL(state)\n *  })\n *  window.onpopstate = function(event){\n *    // This is naive though as you should check if the state is really defined etc.\n *    helper.overrideStateWithoutTriggeringChangeEvent(event.state).search()\n *  }\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function (newState) {\n  this.state = new SearchParameters(newState);\n  return this;\n};\n/**\n * Check if an attribute has any numeric, conjunctive, disjunctive or hierarchical filters.\n * @param {string} attribute the name of the attribute\n * @return {boolean} true if the attribute is filtered by at least one value\n * @example\n * // hasRefinements works with numeric, conjunctive, disjunctive and hierarchical filters\n * helper.hasRefinements('price'); // false\n * helper.addNumericRefinement('price', '>', 100);\n * helper.hasRefinements('price'); // true\n *\n * helper.hasRefinements('color'); // false\n * helper.addFacetRefinement('color', 'blue');\n * helper.hasRefinements('color'); // true\n *\n * helper.hasRefinements('material'); // false\n * helper.addDisjunctiveFacetRefinement('material', 'plastic');\n * helper.hasRefinements('material'); // true\n *\n * helper.hasRefinements('categories'); // false\n * helper.toggleFacetRefinement('categories', 'kitchen > knife');\n * helper.hasRefinements('categories'); // true\n *\n */\n\n\nAlgoliaSearchHelper.prototype.hasRefinements = function (attribute) {\n  if (objectHasKeys(this.state.getNumericRefinements(attribute))) {\n    return true;\n  } else if (this.state.isConjunctiveFacet(attribute)) {\n    return this.state.isFacetRefined(attribute);\n  } else if (this.state.isDisjunctiveFacet(attribute)) {\n    return this.state.isDisjunctiveFacetRefined(attribute);\n  } else if (this.state.isHierarchicalFacet(attribute)) {\n    return this.state.isHierarchicalFacetRefined(attribute);\n  } // there's currently no way to know that the user did call `addNumericRefinement` at some point\n  // thus we cannot distinguish if there once was a numeric refinement that was cleared\n  // so we will return false in every other situations to be consistent\n  // while what we should do here is throw because we did not find the attribute in any type\n  // of refinement\n\n\n  return false;\n};\n/**\n * Check if a value is excluded for a specific faceted attribute. If the value\n * is omitted then the function checks if there is any excluding refinements.\n *\n * @param  {string}  facet name of the attribute for used for faceting\n * @param  {string}  [value] optional value. If passed will test that this value\n   * is filtering the given facet.\n * @return {boolean} true if refined\n * @example\n * helper.isExcludeRefined('color'); // false\n * helper.isExcludeRefined('color', 'blue') // false\n * helper.isExcludeRefined('color', 'red') // false\n *\n * helper.addFacetExclusion('color', 'red');\n *\n * helper.isExcludeRefined('color'); // true\n * helper.isExcludeRefined('color', 'blue') // false\n * helper.isExcludeRefined('color', 'red') // true\n */\n\n\nAlgoliaSearchHelper.prototype.isExcluded = function (facet, value) {\n  return this.state.isExcludeRefined(facet, value);\n};\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasRefinements}\n */\n\n\nAlgoliaSearchHelper.prototype.isDisjunctiveRefined = function (facet, value) {\n  return this.state.isDisjunctiveFacetRefined(facet, value);\n};\n/**\n * Check if the string is a currently filtering tag.\n * @param {string} tag tag to check\n * @return {boolean}\n */\n\n\nAlgoliaSearchHelper.prototype.hasTag = function (tag) {\n  return this.state.isTagRefined(tag);\n};\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasTag}\n */\n\n\nAlgoliaSearchHelper.prototype.isTagRefined = function () {\n  return this.hasTagRefinements.apply(this, arguments);\n};\n/**\n * Get the name of the currently used index.\n * @return {string}\n * @example\n * helper.setIndex('highestPrice_products').getIndex();\n * // returns 'highestPrice_products'\n */\n\n\nAlgoliaSearchHelper.prototype.getIndex = function () {\n  return this.state.index;\n};\n\nfunction getCurrentPage() {\n  return this.state.page;\n}\n/**\n * Get the currently selected page\n * @deprecated\n * @return {number} the current page\n */\n\n\nAlgoliaSearchHelper.prototype.getCurrentPage = getCurrentPage;\n/**\n * Get the currently selected page\n * @function\n * @return {number} the current page\n */\n\nAlgoliaSearchHelper.prototype.getPage = getCurrentPage;\n/**\n * Get all the tags currently set to filters the results.\n *\n * @return {string[]} The list of tags currently set.\n */\n\nAlgoliaSearchHelper.prototype.getTags = function () {\n  return this.state.tagRefinements;\n};\n/**\n * Get the list of refinements for a given attribute. This method works with\n * conjunctive, disjunctive, excluding and numerical filters.\n *\n * See also SearchResults#getRefinements\n *\n * @param {string} facetName attribute name used for faceting\n * @return {Array.<FacetRefinement|NumericRefinement>} All Refinement are objects that contain a value, and\n * a type. Numeric also contains an operator.\n * @example\n * helper.addNumericRefinement('price', '>', 100);\n * helper.getRefinements('price');\n * // [\n * //   {\n * //     \"value\": [\n * //       100\n * //     ],\n * //     \"operator\": \">\",\n * //     \"type\": \"numeric\"\n * //   }\n * // ]\n * @example\n * helper.addFacetRefinement('color', 'blue');\n * helper.addFacetExclusion('color', 'red');\n * helper.getRefinements('color');\n * // [\n * //   {\n * //     \"value\": \"blue\",\n * //     \"type\": \"conjunctive\"\n * //   },\n * //   {\n * //     \"value\": \"red\",\n * //     \"type\": \"exclude\"\n * //   }\n * // ]\n * @example\n * helper.addDisjunctiveFacetRefinement('material', 'plastic');\n * // [\n * //   {\n * //     \"value\": \"plastic\",\n * //     \"type\": \"disjunctive\"\n * //   }\n * // ]\n */\n\n\nAlgoliaSearchHelper.prototype.getRefinements = function (facetName) {\n  var refinements = [];\n\n  if (this.state.isConjunctiveFacet(facetName)) {\n    var conjRefinements = this.state.getConjunctiveRefinements(facetName);\n    conjRefinements.forEach(function (r) {\n      refinements.push({\n        value: r,\n        type: 'conjunctive'\n      });\n    });\n    var excludeRefinements = this.state.getExcludeRefinements(facetName);\n    excludeRefinements.forEach(function (r) {\n      refinements.push({\n        value: r,\n        type: 'exclude'\n      });\n    });\n  } else if (this.state.isDisjunctiveFacet(facetName)) {\n    var disjRefinements = this.state.getDisjunctiveRefinements(facetName);\n    disjRefinements.forEach(function (r) {\n      refinements.push({\n        value: r,\n        type: 'disjunctive'\n      });\n    });\n  }\n\n  var numericRefinements = this.state.getNumericRefinements(facetName);\n  Object.keys(numericRefinements).forEach(function (operator) {\n    var value = numericRefinements[operator];\n    refinements.push({\n      value: value,\n      operator: operator,\n      type: 'numeric'\n    });\n  });\n  return refinements;\n};\n/**\n * Return the current refinement for the (attribute, operator)\n * @param {string} attribute attribute in the record\n * @param {string} operator operator applied on the refined values\n * @return {Array.<number|number[]>} refined values\n */\n\n\nAlgoliaSearchHelper.prototype.getNumericRefinement = function (attribute, operator) {\n  return this.state.getNumericRefinement(attribute, operator);\n};\n/**\n * Get the current breadcrumb for a hierarchical facet, as an array\n * @param  {string} facetName Hierarchical facet name\n * @return {array.<string>} the path as an array of string\n */\n\n\nAlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function (facetName) {\n  return this.state.getHierarchicalFacetBreadcrumb(facetName);\n}; // /////////// PRIVATE\n\n/**\n * Perform the underlying queries\n * @private\n * @return {undefined}\n * @fires search\n * @fires result\n * @fires error\n */\n\n\nAlgoliaSearchHelper.prototype._search = function (options) {\n  var state = this.state;\n  var states = [];\n  var mainQueries = [];\n\n  if (!options.onlyWithDerivedHelpers) {\n    mainQueries = requestBuilder._getQueries(state.index, state);\n    states.push({\n      state: state,\n      queriesCount: mainQueries.length,\n      helper: this\n    });\n    this.emit('search', {\n      state: state,\n      results: this.lastResults\n    });\n  }\n\n  var derivedQueries = this.derivedHelpers.map(function (derivedHelper) {\n    var derivedState = derivedHelper.getModifiedState(state);\n\n    var derivedStateQueries = requestBuilder._getQueries(derivedState.index, derivedState);\n\n    states.push({\n      state: derivedState,\n      queriesCount: derivedStateQueries.length,\n      helper: derivedHelper\n    });\n    derivedHelper.emit('search', {\n      state: derivedState,\n      results: derivedHelper.lastResults\n    });\n    return derivedStateQueries;\n  });\n  var queries = Array.prototype.concat.apply(mainQueries, derivedQueries);\n  var queryId = this._queryId++;\n  this._currentNbQueries++;\n\n  try {\n    this.client.search(queries).then(this._dispatchAlgoliaResponse.bind(this, states, queryId)).catch(this._dispatchAlgoliaError.bind(this, queryId));\n  } catch (error) {\n    // If we reach this part, we're in an internal error state\n    this.emit('error', {\n      error: error\n    });\n  }\n};\n/**\n * Transform the responses as sent by the server and transform them into a user\n * usable object that merge the results of all the batch requests. It will dispatch\n * over the different helper + derived helpers (when there are some).\n * @private\n * @param {array.<{SearchParameters, AlgoliaQueries, AlgoliaSearchHelper}>}\n *  state state used for to generate the request\n * @param {number} queryId id of the current request\n * @param {object} content content of the response\n * @return {undefined}\n */\n\n\nAlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function (states, queryId, content) {\n  // FIXME remove the number of outdated queries discarded instead of just one\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= queryId - this._lastQueryIdReceived;\n  this._lastQueryIdReceived = queryId;\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n  var results = content.results.slice();\n  states.forEach(function (s) {\n    var state = s.state;\n    var queriesCount = s.queriesCount;\n    var helper = s.helper;\n    var specificResults = results.splice(0, queriesCount);\n    var formattedResponse = helper.lastResults = new SearchResults(state, specificResults);\n    helper.emit('result', {\n      results: formattedResponse,\n      state: state\n    });\n  });\n};\n\nAlgoliaSearchHelper.prototype._dispatchAlgoliaError = function (queryId, error) {\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= queryId - this._lastQueryIdReceived;\n  this._lastQueryIdReceived = queryId;\n  this.emit('error', {\n    error: error\n  });\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n};\n\nAlgoliaSearchHelper.prototype.containsRefinement = function (query, facetFilters, numericFilters, tagFilters) {\n  return query || facetFilters.length !== 0 || numericFilters.length !== 0 || tagFilters.length !== 0;\n};\n/**\n * Test if there are some disjunctive refinements on the facet\n * @private\n * @param {string} facet the attribute to test\n * @return {boolean}\n */\n\n\nAlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function (facet) {\n  return this.state.disjunctiveRefinements[facet] && this.state.disjunctiveRefinements[facet].length > 0;\n};\n\nAlgoliaSearchHelper.prototype._change = function (event) {\n  var state = event.state;\n  var isPageReset = event.isPageReset;\n\n  if (state !== this.state) {\n    this.state = state;\n    this.emit('change', {\n      state: this.state,\n      results: this.lastResults,\n      isPageReset: isPageReset\n    });\n  }\n};\n/**\n * Clears the cache of the underlying Algolia client.\n * @return {AlgoliaSearchHelper}\n */\n\n\nAlgoliaSearchHelper.prototype.clearCache = function () {\n  this.client.clearCache && this.client.clearCache();\n  return this;\n};\n/**\n * Updates the internal client instance. If the reference of the clients\n * are equal then no update is actually done.\n * @param  {AlgoliaSearch} newClient an AlgoliaSearch client\n * @return {AlgoliaSearchHelper}\n */\n\n\nAlgoliaSearchHelper.prototype.setClient = function (newClient) {\n  if (this.client === newClient) return this;\n\n  if (typeof newClient.addAlgoliaAgent === 'function') {\n    newClient.addAlgoliaAgent('JS Helper (' + version + ')');\n  }\n\n  this.client = newClient;\n  return this;\n};\n/**\n * Gets the instance of the currently used client.\n * @return {AlgoliaSearch}\n */\n\n\nAlgoliaSearchHelper.prototype.getClient = function () {\n  return this.client;\n};\n/**\n * Creates an derived instance of the Helper. A derived helper\n * is a way to request other indices synchronised with the lifecycle\n * of the main Helper. This mechanism uses the multiqueries feature\n * of Algolia to aggregate all the requests in a single network call.\n *\n * This method takes a function that is used to create a new SearchParameter\n * that will be used to create requests to Algolia. Those new requests\n * are created just before the `search` event. The signature of the function\n * is `SearchParameters -> SearchParameters`.\n *\n * This method returns a new DerivedHelper which is an EventEmitter\n * that fires the same `search`, `result` and `error` events. Those\n * events, however, will receive data specific to this DerivedHelper\n * and the SearchParameters that is returned by the call of the\n * parameter function.\n * @param {function} fn SearchParameters -> SearchParameters\n * @return {DerivedHelper}\n */\n\n\nAlgoliaSearchHelper.prototype.derive = function (fn) {\n  var derivedHelper = new DerivedHelper(this, fn);\n  this.derivedHelpers.push(derivedHelper);\n  return derivedHelper;\n};\n/**\n * This method detaches a derived Helper from the main one. Prefer using the one from the\n * derived helper itself, to remove the event listeners too.\n * @private\n * @return {undefined}\n * @throws Error\n */\n\n\nAlgoliaSearchHelper.prototype.detachDerivedHelper = function (derivedHelper) {\n  var pos = this.derivedHelpers.indexOf(derivedHelper);\n  if (pos === -1) throw new Error('Derived helper already detached');\n  this.derivedHelpers.splice(pos, 1);\n};\n/**\n * This method returns true if there is currently at least one on-going search.\n * @return {boolean} true if there is a search pending\n */\n\n\nAlgoliaSearchHelper.prototype.hasPendingRequests = function () {\n  return this._currentNbQueries > 0;\n};\n/**\n * @typedef AlgoliaSearchHelper.NumericRefinement\n * @type {object}\n * @property {number[]} value the numbers that are used for filtering this attribute with\n * the operator specified.\n * @property {string} operator the faceting data: value, number of entries\n * @property {string} type will be 'numeric'\n */\n\n/**\n * @typedef AlgoliaSearchHelper.FacetRefinement\n * @type {object}\n * @property {string} value the string use to filter the attribute\n * @property {string} type the type of filter: 'conjunctive', 'disjunctive', 'exclude'\n */\n\n\nmodule.exports = AlgoliaSearchHelper;","'use strict';\n\nfunction _interopDefault(ex) {\n  return ex && typeof ex === 'object' && 'default' in ex ? ex['default'] : ex;\n}\n\nvar React = require('react');\n\nvar React__default = _interopDefault(React);\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nvar canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient, mapStateOnServer) {\n  if (typeof reducePropsToState !== 'function') {\n    throw new Error('Expected reducePropsToState to be a function.');\n  }\n\n  if (typeof handleStateChangeOnClient !== 'function') {\n    throw new Error('Expected handleStateChangeOnClient to be a function.');\n  }\n\n  if (typeof mapStateOnServer !== 'undefined' && typeof mapStateOnServer !== 'function') {\n    throw new Error('Expected mapStateOnServer to either be undefined or a function.');\n  }\n\n  function getDisplayName(WrappedComponent) {\n    return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n  }\n\n  return function wrap(WrappedComponent) {\n    if (typeof WrappedComponent !== 'function') {\n      throw new Error('Expected WrappedComponent to be a React component.');\n    }\n\n    var mountedInstances = [];\n    var state;\n\n    function emitChange() {\n      state = reducePropsToState(mountedInstances.map(function (instance) {\n        return instance.props;\n      }));\n\n      if (SideEffect.canUseDOM) {\n        handleStateChangeOnClient(state);\n      } else if (mapStateOnServer) {\n        state = mapStateOnServer(state);\n      }\n    }\n\n    var SideEffect = /*#__PURE__*/function (_PureComponent) {\n      _inheritsLoose(SideEffect, _PureComponent);\n\n      function SideEffect() {\n        return _PureComponent.apply(this, arguments) || this;\n      } // Try to use displayName of wrapped component\n      // Expose canUseDOM so tests can monkeypatch it\n\n\n      SideEffect.peek = function peek() {\n        return state;\n      };\n\n      SideEffect.rewind = function rewind() {\n        if (SideEffect.canUseDOM) {\n          throw new Error('You may only call rewind() on the server. Call peek() to read the current state.');\n        }\n\n        var recordedState = state;\n        state = undefined;\n        mountedInstances = [];\n        return recordedState;\n      };\n\n      var _proto = SideEffect.prototype;\n\n      _proto.UNSAFE_componentWillMount = function UNSAFE_componentWillMount() {\n        mountedInstances.push(this);\n        emitChange();\n      };\n\n      _proto.componentDidUpdate = function componentDidUpdate() {\n        emitChange();\n      };\n\n      _proto.componentWillUnmount = function componentWillUnmount() {\n        var index = mountedInstances.indexOf(this);\n        mountedInstances.splice(index, 1);\n        emitChange();\n      };\n\n      _proto.render = function render() {\n        return /*#__PURE__*/React__default.createElement(WrappedComponent, this.props);\n      };\n\n      return SideEffect;\n    }(React.PureComponent);\n\n    _defineProperty(SideEffect, \"displayName\", \"SideEffect(\" + getDisplayName(WrappedComponent) + \")\");\n\n    _defineProperty(SideEffect, \"canUseDOM\", canUseDOM);\n\n    return SideEffect;\n  };\n}\n\nmodule.exports = withSideEffect;","'use strict';\nvar $ = require('../internals/export');\nvar $reduceRight = require('../internals/array-reduce').right;\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\nvar arrayMethodUsesToLength = require('../internals/array-method-uses-to-length');\nvar CHROME_VERSION = require('../internals/engine-v8-version');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar STRICT_METHOD = arrayMethodIsStrict('reduceRight');\n// For preventing possible almost infinite loop in non-standard implementations, test the forward version of the method\nvar USES_TO_LENGTH = arrayMethodUsesToLength('reduce', { 1: 0 });\n// Chrome 80-82 has a critical bug\n// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982\nvar CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83;\n\n// `Array.prototype.reduceRight` method\n// https://tc39.es/ecma262/#sec-array.prototype.reduceright\n$({ target: 'Array', proto: true, forced: !STRICT_METHOD || !USES_TO_LENGTH || CHROME_BUG }, {\n  reduceRight: function reduceRight(callbackfn /* , initialValue */) {\n    return $reduceRight(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n","import React from \"react\";\r\nimport PropTypes from \"prop-types\";\r\n\r\nconst LandsLogo = ({ rootCssClasses }) => (\r\n  <svg viewBox=\"0 0 250 44.29\" className={rootCssClasses}>\r\n    <g>\r\n      <path\r\n        d=\"M12.79.25s-2.68,13.53,3.79,22.32,20.09,7.48,20.09,7.48A21.44,21.44,0,0,0,34.4,14.88C30,6.72,20,4.42,16.61,3.11A8.44,8.44,0,0,1,12.79.25Z\"\r\n        fill=\"#dfdd00\"\r\n        opacity=\"0.7\"\r\n      />\r\n      <path\r\n        d=\"M37.27,25.52a23.06,23.06,0,0,0-2.79-10.69C30.7,7.78,22.71,5.09,18.41,3.64c-.69-.23-1.29-.44-1.76-.62A8.43,8.43,0,0,1,12.87.2L12.74,0l0,.23a39.14,39.14,0,0,0-.53,7.89c.13,4.1,1,9.95,4.34,14.51S25.17,29,29,29.7a32.42,32.42,0,0,0,5.75.51c1.16,0,1.87-.07,1.89-.07h.06l0-.06A17.15,17.15,0,0,0,37.27,25.52Zm-3-10.6c.3.57.57,1.13.82,1.68h0a25.4,25.4,0,0,1-2.49,10.92,46.87,46.87,0,0,1-5.28-4.23c.49-1,3.65-7.68,3-13.29A17.63,17.63,0,0,1,34.31,14.92Zm-21,.17A20.46,20.46,0,0,0,22,17.72h0c.6.8,1.22,1.57,1.85,2.28,1.08,1.21,2.15,2.3,3.2,3.28-1,0-7.38-.09-11.14-1.87A22.1,22.1,0,0,1,13.29,15.09ZM12.36,8.3A16.65,16.65,0,0,0,15.58,10c.47.19,1,.37,1.36.5a3.11,3.11,0,0,0,.57.15,62.46,62.46,0,0,0,4.34,6.85,20,20,0,0,1-8.62-2.69A33,33,0,0,1,12.36,8.3ZM22,17.38a62.42,62.42,0,0,1-4.33-6.84l.18-.31c.65-1.07,2.36-3.88,1.59-6,1.33.46,2.89,1,4.52,1.78C24.59,10.48,22.44,16.23,22,17.38Zm2,2.49c-.64-.72-1.27-1.5-1.88-2.31.34-.85,2.65-6.79,2-11.49a26.36,26.36,0,0,1,6,3.78h0c.71,5.51-2.39,12.16-2.95,13.31C26.15,22.18,25.07,21.09,24,19.87ZM16.58,3.2c.47.18,1.07.39,1.77.62l.85.29a.09.09,0,0,0,0,0c.84,2.09-.88,4.92-1.53,6l-.13.21A97.87,97.87,0,0,1,12.85.5,8.88,8.88,0,0,0,16.58,3.2ZM12.78.84a98.89,98.89,0,0,0,4.6,9.61,18,18,0,0,1-5-2.4A40.58,40.58,0,0,1,12.78.84Zm3.87,21.67q-.29-.4-.56-.81c3.88,1.71,10.13,1.77,11,1.77h.16a47.12,47.12,0,0,0,5.19,4.16,28,28,0,0,1-9,.15A16.76,16.76,0,0,1,16.66,22.51Zm12.41,7a25.37,25.37,0,0,1-5-1.43,28,28,0,0,0,3.36.2,25.93,25.93,0,0,0,5.22-.49h0A34.11,34.11,0,0,0,36.31,30,31.73,31.73,0,0,1,29.06,29.51Zm7.54.41a32.17,32.17,0,0,1-3.83-2.28A25.41,25.41,0,0,0,35.29,17a22.66,22.66,0,0,1,1.78,8.54A17.65,17.65,0,0,1,36.61,29.91Z\"\r\n        fill=\"#fff\"\r\n      />\r\n    </g>\r\n    <g>\r\n      <path\r\n        d=\"M6.72,6.22S4,19.75,10.51,28.53,30.6,36,30.6,36a21.44,21.44,0,0,0-2.27-15.17C24,12.69,13.91,10.39,10.54,9.08A8.44,8.44,0,0,1,6.72,6.22Z\"\r\n        fill=\"#92af1e\"\r\n        opacity=\"0.7\"\r\n      />\r\n      <path\r\n        d=\"M31.2,31.49A23.06,23.06,0,0,0,28.41,20.8C24.63,13.75,16.63,11.05,12.34,9.6,11.64,9.37,11,9.17,10.58,9A8.43,8.43,0,0,1,6.8,6.16L6.67,6l0,.23a39.14,39.14,0,0,0-.53,7.89c.13,4.1,1,9.95,4.34,14.51S19.1,35,23,35.66a32.42,32.42,0,0,0,5.75.51c1.16,0,1.87-.07,1.89-.07h.06l0-.06A17.15,17.15,0,0,0,31.2,31.49Zm-3-10.6c.3.57.57,1.13.82,1.68h0a25.4,25.4,0,0,1-2.49,10.92,46.87,46.87,0,0,1-5.28-4.23c.49-1,3.65-7.68,3-13.29A17.63,17.63,0,0,1,28.24,20.89Zm-21,.17a20.46,20.46,0,0,0,8.69,2.63h0c.6.8,1.22,1.57,1.85,2.28,1.08,1.21,2.15,2.3,3.2,3.28-1,0-7.38-.09-11.14-1.87A22.1,22.1,0,0,1,7.22,21.06Zm8.69,2.29a62.43,62.43,0,0,1-4.33-6.84l.18-.31c.65-1.07,2.36-3.88,1.59-6,1.33.46,2.89,1,4.52,1.78C18.52,16.44,16.37,22.19,15.91,23.34Zm-.14.14a20,20,0,0,1-8.62-2.69,33,33,0,0,1-.86-6.52A16.65,16.65,0,0,0,9.51,16c.47.19,1,.37,1.36.5a3.11,3.11,0,0,0,.57.15A62.47,62.47,0,0,0,15.77,23.48Zm2.15,2.36c-.64-.72-1.27-1.5-1.88-2.31.34-.85,2.65-6.79,2-11.49a26.37,26.37,0,0,1,6,3.78h0c.71,5.51-2.39,12.16-3,13.31C20.08,28.14,19,27.05,17.92,25.84ZM10.51,9.17c.47.18,1.07.39,1.77.62l.85.29a.09.09,0,0,0,0,0c.84,2.09-.88,4.92-1.53,6l-.13.21A97.88,97.88,0,0,1,6.78,6.46,8.88,8.88,0,0,0,10.51,9.17ZM6.71,6.81a98.89,98.89,0,0,0,4.6,9.61,18,18,0,0,1-5-2.4A40.58,40.58,0,0,1,6.71,6.81Zm3.87,21.67q-.29-.4-.56-.81c3.88,1.71,10.13,1.77,11,1.77h.16a47.11,47.11,0,0,0,5.19,4.16,28,28,0,0,1-9,.15A16.76,16.76,0,0,1,10.59,28.48Zm12.41,7A25.38,25.38,0,0,1,18,34a28,28,0,0,0,3.36.2,25.93,25.93,0,0,0,5.22-.49h0a34.11,34.11,0,0,0,3.64,2.19A31.73,31.73,0,0,1,23,35.47Zm7.54.4a32.16,32.16,0,0,1-3.83-2.28,25.41,25.41,0,0,0,2.51-10.66A22.66,22.66,0,0,1,31,31.48,17.66,17.66,0,0,1,30.54,35.88Z\"\r\n        fill=\"#fff\"\r\n      />\r\n    </g>\r\n    <g>\r\n      <path\r\n        d=\"M.65,12.18S-2,25.71,4.44,34.5,24.53,42,24.53,42a21.44,21.44,0,0,0-2.27-15.17C17.89,18.65,7.84,16.35,4.47,15A8.44,8.44,0,0,1,.65,12.18Z\"\r\n        fill=\"#4da92c\"\r\n        opacity=\"0.8\"\r\n      />\r\n      <path\r\n        d=\"M25.13,37.45a23.07,23.07,0,0,0-2.79-10.69C18.56,19.71,10.56,17,6.27,15.57,5.57,15.34,5,15.13,4.51,15A8.43,8.43,0,0,1,.73,12.13l-.13-.2,0,.23A39.14,39.14,0,0,0,0,20C.15,24.15,1,30,4.36,34.56S13,40.92,16.89,41.63a32.42,32.42,0,0,0,5.75.51c1.16,0,1.87-.07,1.89-.07h.06l0-.06A17.15,17.15,0,0,0,25.13,37.45Zm-3-10.6c.3.57.57,1.13.82,1.68h0a25.4,25.4,0,0,1-2.49,10.92,46.87,46.87,0,0,1-5.28-4.23c.49-1,3.65-7.68,3-13.29A17.63,17.63,0,0,1,22.17,26.85ZM1.15,27a20.46,20.46,0,0,0,8.69,2.63h0c.6.8,1.22,1.57,1.85,2.28,1.08,1.21,2.15,2.3,3.2,3.28-1,0-7.38-.09-11.14-1.87A22.1,22.1,0,0,1,1.15,27ZM.22,20.23a16.65,16.65,0,0,0,3.22,1.72c.47.19,1,.37,1.36.5a3.11,3.11,0,0,0,.57.15A62.46,62.46,0,0,0,9.7,29.45a20,20,0,0,1-8.62-2.69A33,33,0,0,1,.22,20.23Zm9.62,9.08a62.42,62.42,0,0,1-4.33-6.84l.18-.31c.65-1.07,2.36-3.88,1.59-6,1.33.46,2.89,1,4.52,1.78C12.45,22.41,10.3,28.16,9.84,29.31Zm2,2.49c-.64-.72-1.27-1.5-1.88-2.31.34-.85,2.65-6.79,2-11.49a26.36,26.36,0,0,1,6,3.78h0c.71,5.51-2.39,12.16-2.95,13.31C14,34.11,12.93,33,11.85,31.8ZM4.44,15.13c.47.18,1.07.39,1.77.62l.85.29a.09.09,0,0,0,0,0c.84,2.09-.88,4.92-1.53,6l-.13.21A97.87,97.87,0,0,1,.71,12.43,8.88,8.88,0,0,0,4.44,15.13ZM.64,12.77a98.9,98.9,0,0,0,4.6,9.61,18,18,0,0,1-5-2.4A40.58,40.58,0,0,1,.64,12.77ZM4.51,34.44Q4.22,34,4,33.63c3.88,1.71,10.13,1.77,11,1.77h.16a47.11,47.11,0,0,0,5.19,4.16,28,28,0,0,1-9,.15A16.76,16.76,0,0,1,4.51,34.44Zm12.41,7a25.38,25.38,0,0,1-5-1.44,28,28,0,0,0,3.36.2,25.93,25.93,0,0,0,5.22-.49h0a34.11,34.11,0,0,0,3.64,2.19A31.73,31.73,0,0,1,16.93,41.44Zm7.54.4a32.16,32.16,0,0,1-3.83-2.28,25.41,25.41,0,0,0,2.51-10.66,22.66,22.66,0,0,1,1.78,8.54A17.66,17.66,0,0,1,24.46,41.84Z\"\r\n        fill=\"#fff\"\r\n      />\r\n    </g>\r\n    <g fill=\"#434041\">\r\n      <path d=\"M45.91,8V32.69H57v3.2H42.28V8Z\" />\r\n      <path d=\"M73,16.21q1.68,1.64,1.68,5.22V35.89H71.24V32.57q-2.47,3.84-5.59,3.84A4.94,4.94,0,0,1,61.7,34.7,6.88,6.88,0,0,1,60.23,30V28.86A5.64,5.64,0,0,1,62,24.61a6.48,6.48,0,0,1,4.69-1.68,23.79,23.79,0,0,1,4.39.55V21.14a3.57,3.57,0,0,0-.83-2.64,3.58,3.58,0,0,0-2.58-.81,36.37,36.37,0,0,0-5.76.64V15.21a41.77,41.77,0,0,1,5.76-.64Q71.32,14.57,73,16.21ZM64.84,26.68a3.58,3.58,0,0,0-.94,2.64v.47a3.82,3.82,0,0,0,.73,2.47,2.26,2.26,0,0,0,1.83.9,3.76,3.76,0,0,0,2.37-1,9.81,9.81,0,0,0,2.24-2.84V26a19.38,19.38,0,0,0-3.5-.3A3.7,3.7,0,0,0,64.84,26.68Z\" />\r\n      <path d=\"M93.73,16.42a8.3,8.3,0,0,1,1.47,5.27v14.2H91.58V22.2q0-4.26-2.77-4.26a4.26,4.26,0,0,0-2.52.94,8.21,8.21,0,0,0-2.22,2.56V35.89H80.45V15.08h3.41v3.11a9.18,9.18,0,0,1,2.58-2.69,5.53,5.53,0,0,1,3.09-.94A5,5,0,0,1,93.73,16.42Z\" />\r\n      <path d=\"M115.5,35.89H112V32.52q-2.56,3.88-5.84,3.88a4.82,4.82,0,0,1-4.05-1.81,8.53,8.53,0,0,1-1.41-5.31V21.69a8,8,0,0,1,1.56-5.25,5.46,5.46,0,0,1,4.46-1.88,6.32,6.32,0,0,1,2.6.62,12.45,12.45,0,0,1,2.52,1.51V6.77h3.62Zm-10.3-17a5.42,5.42,0,0,0-.83,3.3v6.61q0,4.35,2.69,4.35a4.06,4.06,0,0,0,2.54-1,9.45,9.45,0,0,0,2.28-2.84V19.94a7.41,7.41,0,0,0-2.11-1.54,5.07,5.07,0,0,0-2.2-.6A2.8,2.8,0,0,0,105.2,18.9Z\" />\r\n      <path d=\"M131.75,15.08l-.08,3.07a18.14,18.14,0,0,0-4.05-.51q-3.84,0-3.84,2.47v.38a1.82,1.82,0,0,0,.41,1.24,4.63,4.63,0,0,0,1.47,1l4,1.88q3.62,1.71,3.62,5v.94a5.59,5.59,0,0,1-1.77,4.41q-1.73,1.47-5.44,1.47a24.61,24.61,0,0,1-5.5-.9l.17-3.24a19.49,19.49,0,0,0,5.25.94,5.28,5.28,0,0,0,2.9-.58,2.17,2.17,0,0,0,.81-1.9v-.43a2.85,2.85,0,0,0-.4-1.62,3.15,3.15,0,0,0-1.34-1l-4.14-1.83a6.79,6.79,0,0,1-2.75-2,4.56,4.56,0,0,1-.87-2.77v-.6A5.66,5.66,0,0,1,122,16q1.73-1.47,5.44-1.47A22.16,22.16,0,0,1,131.75,15.08Z\" />\r\n      <path d=\"M161.28,10.33Q164,13.21,164,18.62v7q0,5.2-2.75,8t-8,2.79q-3.62,0-7.59-.26V7.62q3.84-.17,7.8-.17Q158.53,7.45,161.28,10.33Zm-12,.28V33q2.52.26,4,.26a7.15,7.15,0,0,0,5.22-1.9,7.32,7.32,0,0,0,1.94-5.48V18.37q0-3.88-1.88-5.86a6.93,6.93,0,0,0-5.29-2Q151.92,10.52,149.27,10.6Z\" />\r\n      <path d=\"M182.07,16.53a7.89,7.89,0,0,1,1.88,5.67V26.6H173v2.52a4.08,4.08,0,0,0,1,3.13,4.78,4.78,0,0,0,3.3,1,28.52,28.52,0,0,0,5.54-.68l.09,3.16a36.31,36.31,0,0,1-5.67.73q-4.22,0-6.08-1.83t-1.85-5.67V22.2a8.06,8.06,0,0,1,1.81-5.67,7,7,0,0,1,5.44-2A7.21,7.21,0,0,1,182.07,16.53ZM174,18.64a4.23,4.23,0,0,0-1,3v2h7.33V21.78a4.39,4.39,0,0,0-1-3.11,3.54,3.54,0,0,0-2.71-1.07A3.45,3.45,0,0,0,174,18.64Z\" />\r\n      <path d=\"M199.13,15.08,199,18.15a18.14,18.14,0,0,0-4.05-.51q-3.84,0-3.84,2.47v.38a1.82,1.82,0,0,0,.41,1.24,4.63,4.63,0,0,0,1.47,1l4,1.88q3.62,1.71,3.62,5v.94a5.59,5.59,0,0,1-1.77,4.41q-1.73,1.47-5.44,1.47a24.61,24.61,0,0,1-5.5-.9l.17-3.24a19.49,19.49,0,0,0,5.25.94,5.28,5.28,0,0,0,2.9-.58,2.17,2.17,0,0,0,.81-1.9v-.43a2.85,2.85,0,0,0-.4-1.62,3.15,3.15,0,0,0-1.34-1l-4.14-1.83a6.79,6.79,0,0,1-2.75-2,4.56,4.56,0,0,1-.87-2.77v-.6A5.66,5.66,0,0,1,189.38,16q1.73-1.47,5.44-1.47A22.16,22.16,0,0,1,199.13,15.08Z\" />\r\n      <path d=\"M208.91,7.19a1.78,1.78,0,0,1,.62,1.45V9.88a1.71,1.71,0,0,1-.62,1.43,2.79,2.79,0,0,1-1.77.49,2.71,2.71,0,0,1-1.73-.49,1.71,1.71,0,0,1-.62-1.43V8.64a1.78,1.78,0,0,1,.62-1.45,2.63,2.63,0,0,1,1.73-.51A2.71,2.71,0,0,1,208.91,7.19Zm.06,7.89V35.89h-3.62V15.08Z\" />\r\n      <path d=\"M225.18,15.12l6.65-.09v3.2l-3.5-.09a7.41,7.41,0,0,1,.73,3.2v.94a6.73,6.73,0,0,1-1.92,5,7.31,7.31,0,0,1-5.37,1.9,12.78,12.78,0,0,1-3.62-.43,2.23,2.23,0,0,0-.94,1.75v.26a1.17,1.17,0,0,0,.43,1,3.38,3.38,0,0,0,1.66.4l6.35.47a4.74,4.74,0,0,1,3.18,1.47A4.59,4.59,0,0,1,230,37.38V39a5.53,5.53,0,0,1-.73,3,4.59,4.59,0,0,1-2.67,1.75,20,20,0,0,1-5.57.6,20.72,20.72,0,0,1-3.22-.3,31.43,31.43,0,0,1-3.52-.77l.13-3.37a22,22,0,0,0,6.74,1.32,15.61,15.61,0,0,0,3.43-.28,2.4,2.4,0,0,0,1.49-.83,3.08,3.08,0,0,0,.36-1.66v-.34a1.95,1.95,0,0,0-2-2.13l-6.4-.43a4.78,4.78,0,0,1-3.11-1.15,3.66,3.66,0,0,1-1.07-2.77v-.85a3.78,3.78,0,0,1,.49-1.83,4.82,4.82,0,0,1,1.43-1.58,4.82,4.82,0,0,1-1-2.07,12.77,12.77,0,0,1-.32-3.09v-.94a6.42,6.42,0,0,1,1.88-4.84,7.55,7.55,0,0,1,5.46-1.81A10,10,0,0,1,225.18,15.12ZM219,18.51a3.46,3.46,0,0,0-1,2.62v1.41a7.15,7.15,0,0,0,.28,2.32,1.66,1.66,0,0,0,1,1,6.43,6.43,0,0,0,2.18.28,4.11,4.11,0,0,0,2.94-.94,3.54,3.54,0,0,0,1-2.69V21.26a8.6,8.6,0,0,0-.51-3.11,7.47,7.47,0,0,0-1.39-.38,9.25,9.25,0,0,0-1.77-.17A3.83,3.83,0,0,0,219,18.51Z\" />\r\n      <path d=\"M248.53,16.42A8.3,8.3,0,0,1,250,21.69v14.2h-3.62V22.2q0-4.26-2.77-4.26a4.26,4.26,0,0,0-2.52.94,8.21,8.21,0,0,0-2.22,2.56V35.89h-3.62V15.08h3.41v3.11a9.18,9.18,0,0,1,2.58-2.69,5.53,5.53,0,0,1,3.09-.94A5,5,0,0,1,248.53,16.42Z\" />\r\n    </g>\r\n  </svg>\r\n);\r\n\r\nLandsLogo.propTypes = {\r\n  rootCssClasses: PropTypes.string,\r\n};\r\n\r\nLandsLogo.defaultProps = {\r\n  rootCssClasses: \"\",\r\n};\r\n\r\nexport default LandsLogo;\r\n","/* eslint-disable jsx-a11y/no-onchange */\r\n\r\nimport React, { useMemo } from \"react\";\r\nimport { navigate, useStaticQuery, graphql } from \"gatsby\";\r\n\r\nimport { useIntl } from \"../contexts/IntlContext\";\r\n\r\n/**\r\n * Creates the list of language options for each translation available.\r\n * @param {Object} translationsData Keys are the locales and value is the path {<locale>: <path>}\r\n * @param {Object[]} languagesData Each object has a 'locale' ex: en-us, and 'name' ex: English\r\n */\r\nconst createLangOptions = (translationsData, languagesData) => {\r\n  const options = [];\r\n  for (const key of Object.keys(translationsData)) {\r\n    options.push(\r\n      <option value={key} key={key}>\r\n        {languagesData.find(l => l.locale === key)?.name ?? key}\r\n      </option>\r\n    );\r\n  }\r\n  return options;\r\n};\r\n\r\nconst Language = () => {\r\n  const { lang, storeLang, translations } = useIntl();\r\n\r\n  const {\r\n    allLanguage: { nodes: languages },\r\n  } = useStaticQuery(graphql`\r\n    query LanguagesQuery {\r\n      allLanguage {\r\n        nodes {\r\n          locale\r\n          name\r\n        }\r\n      }\r\n    }\r\n  `);\r\n\r\n  const options = useMemo(() => createLangOptions(translations, languages), [\r\n    translations,\r\n  ]);\r\n\r\n  return (\r\n    <>\r\n      {Object.keys(translations).length > 0 ? (\r\n        <form className=\"relative\">\r\n          <label htmlFor=\"lang\" className=\"sr-only\">\r\n            Language picker\r\n          </label>\r\n          <select\r\n            name=\"lang\"\r\n            id=\"lang\"\r\n            className=\"appearance-none block bg-transparent pr-6 py-1 text-gray-500 font-medium focus:outline-none focus:text-gray-900 cursor-pointer transition-colors duration-200\"\r\n            value={lang}\r\n            onChange={e => {\r\n              const lang = e.target.value;\r\n              navigate(translations[lang]);\r\n              storeLang(lang);\r\n            }}\r\n          >\r\n            {options}\r\n          </select>\r\n          <svg\r\n            className=\"w-5 h-5 text-gray-500 absolute top-1/2 right-0 -mt-2.5 pointer-events-none\"\r\n            fill=\"currentColor\"\r\n          >\r\n            <path d=\"M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z\" />\r\n          </svg>\r\n        </form>\r\n      ) : null}\r\n    </>\r\n  );\r\n};\r\n\r\nexport default Language;\r\n","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}","import defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nexport default function _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? Object(arguments[i]) : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}","export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}","import _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nexport default function _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"@babel/runtime/helpers/esm/setPrototypeOf\";\nexport default function _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}","import objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nexport default function _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}","import \"core-js/modules/es.array.reduce.js\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\"; // From https://github.com/reactjs/react-redux/blob/master/src/utils/shallowEqual.js\n\nexport var shallowEqual = function shallowEqual(objA, objB) {\n  if (objA === objB) {\n    return true;\n  }\n\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  } // Test for A's keys different from B.\n\n\n  var hasOwn = Object.prototype.hasOwnProperty;\n\n  for (var i = 0; i < keysA.length; i++) {\n    if (!hasOwn.call(objB, keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {\n      return false;\n    }\n  }\n\n  return true;\n};\nexport var getDisplayName = function getDisplayName(Component) {\n  return Component.displayName || Component.name || 'UnknownComponent';\n};\nvar resolved = Promise.resolve();\nexport var defer = function defer(f) {\n  resolved.then(f);\n};\n\nvar isPlainObject = function isPlainObject(value) {\n  return _typeof(value) === 'object' && value !== null && !Array.isArray(value);\n};\n\nexport var removeEmptyKey = function removeEmptyKey(obj) {\n  Object.keys(obj).forEach(function (key) {\n    var value = obj[key];\n\n    if (!isPlainObject(value)) {\n      return;\n    }\n\n    if (!objectHasKeys(value)) {\n      delete obj[key];\n    } else {\n      removeEmptyKey(value);\n    }\n  });\n  return obj;\n};\nexport var removeEmptyArraysFromObject = function removeEmptyArraysFromObject(obj) {\n  Object.keys(obj).forEach(function (key) {\n    var value = obj[key];\n\n    if (Array.isArray(value) && value.length === 0) {\n      delete obj[key];\n    }\n  });\n  return obj;\n};\nexport function addAbsolutePositions(hits, hitsPerPage, page) {\n  return hits.map(function (hit, index) {\n    return _objectSpread({}, hit, {\n      __position: hitsPerPage * page + index + 1\n    });\n  });\n}\nexport function addQueryID(hits, queryID) {\n  if (!queryID) {\n    return hits;\n  }\n\n  return hits.map(function (hit) {\n    return _objectSpread({}, hit, {\n      __queryID: queryID\n    });\n  });\n}\nexport function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return undefined;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return array[i];\n    }\n  }\n\n  return undefined;\n}\nexport function objectHasKeys(object) {\n  return object && Object.keys(object).length > 0;\n} // https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620\n\nexport function omit(source, excluded) {\n  if (source === null || source === undefined) {\n    return {};\n  }\n\n  var target = {};\n  var sourceKeys = Object.keys(source);\n\n  for (var i = 0; i < sourceKeys.length; i++) {\n    var _key = sourceKeys[i];\n\n    if (excluded.indexOf(_key) >= 0) {\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n\n    target[_key] = source[_key];\n  }\n\n  return target;\n}\n/**\n * Retrieve the value at a path of the object:\n *\n * @example\n * getPropertyByPath(\n *   { test: { this: { function: [{ now: { everyone: true } }] } } },\n *   'test.this.function[0].now.everyone'\n * ); // true\n *\n * getPropertyByPath(\n *   { test: { this: { function: [{ now: { everyone: true } }] } } },\n *   ['test', 'this', 'function', 0, 'now', 'everyone']\n * ); // true\n *\n * @param object Source object to query\n * @param path either an array of properties, or a string form of the properties, separated by .\n */\n\nexport var getPropertyByPath = function getPropertyByPath(object, path) {\n  return (Array.isArray(path) ? path : path.replace(/\\[(\\d+)]/g, '.$1').split('.')).reduce(function (current, key) {\n    return current ? current[key] : undefined;\n  }, object);\n};\nexport function getObjectType(object) {\n  return Object.prototype.toString.call(object).slice(8, -1);\n}","import { defer } from './utils';\nexport default function createWidgetsManager(onWidgetsUpdate) {\n  var widgets = []; // Is an update scheduled?\n\n  var scheduled = false; // The state manager's updates need to be batched since more than one\n  // component can register or unregister widgets during the same tick.\n\n  function scheduleUpdate() {\n    if (scheduled) {\n      return;\n    }\n\n    scheduled = true;\n    defer(function () {\n      scheduled = false;\n      onWidgetsUpdate();\n    });\n  }\n\n  return {\n    registerWidget: function registerWidget(widget) {\n      widgets.push(widget);\n      scheduleUpdate();\n      return function unregisterWidget() {\n        widgets.splice(widgets.indexOf(widget), 1);\n        scheduleUpdate();\n      };\n    },\n    update: scheduleUpdate,\n    getWidgets: function getWidgets() {\n      return widgets;\n    }\n  };\n}","import { getPropertyByPath } from './utils';\nexport var HIGHLIGHT_TAGS = {\n  highlightPreTag: \"<ais-highlight-0000000000>\",\n  highlightPostTag: \"</ais-highlight-0000000000>\"\n};\n/**\n * Parses an highlighted attribute into an array of objects with the string value, and\n * a boolean that indicated if this part is highlighted.\n *\n * @param {string} preTag - string used to identify the start of an highlighted value\n * @param {string} postTag - string used to identify the end of an highlighted value\n * @param {string} highlightedValue - highlighted attribute as returned by Algolia highlight feature\n * @return {object[]} - An array of {value: string, isHighlighted: boolean}.\n */\n\nfunction parseHighlightedAttribute(_ref) {\n  var preTag = _ref.preTag,\n      postTag = _ref.postTag,\n      _ref$highlightedValue = _ref.highlightedValue,\n      highlightedValue = _ref$highlightedValue === void 0 ? '' : _ref$highlightedValue;\n  var splitByPreTag = highlightedValue.split(preTag);\n  var firstValue = splitByPreTag.shift();\n  var elements = firstValue === '' ? [] : [{\n    value: firstValue,\n    isHighlighted: false\n  }];\n\n  if (postTag === preTag) {\n    var isHighlighted = true;\n    splitByPreTag.forEach(function (split) {\n      elements.push({\n        value: split,\n        isHighlighted: isHighlighted\n      });\n      isHighlighted = !isHighlighted;\n    });\n  } else {\n    splitByPreTag.forEach(function (split) {\n      var splitByPostTag = split.split(postTag);\n      elements.push({\n        value: splitByPostTag[0],\n        isHighlighted: true\n      });\n\n      if (splitByPostTag[1] !== '') {\n        elements.push({\n          value: splitByPostTag[1],\n          isHighlighted: false\n        });\n      }\n    });\n  }\n\n  return elements;\n}\n/**\n * Find an highlighted attribute given an `attribute` and an `highlightProperty`, parses it,\n * and provided an array of objects with the string value and a boolean if this\n * value is highlighted.\n *\n * In order to use this feature, highlight must be activated in the configuration of\n * the index. The `preTag` and `postTag` attributes are respectively highlightPreTag and\n * highlightPostTag in Algolia configuration.\n *\n * @param {string} preTag - string used to identify the start of an highlighted value\n * @param {string} postTag - string used to identify the end of an highlighted value\n * @param {string} highlightProperty - the property that contains the highlight structure in the results\n * @param {string} attribute - the highlighted attribute to look for\n * @param {object} hit - the actual hit returned by Algolia.\n * @return {object[]} - An array of {value: string, isHighlighted: boolean}.\n */\n\n\nexport function parseAlgoliaHit(_ref2) {\n  var _ref2$preTag = _ref2.preTag,\n      preTag = _ref2$preTag === void 0 ? '<em>' : _ref2$preTag,\n      _ref2$postTag = _ref2.postTag,\n      postTag = _ref2$postTag === void 0 ? '</em>' : _ref2$postTag,\n      highlightProperty = _ref2.highlightProperty,\n      attribute = _ref2.attribute,\n      hit = _ref2.hit;\n  if (!hit) throw new Error('`hit`, the matching record, must be provided');\n  var highlightObject = getPropertyByPath(hit[highlightProperty], attribute) || {};\n\n  if (Array.isArray(highlightObject)) {\n    return highlightObject.map(function (item) {\n      return parseHighlightedAttribute({\n        preTag: preTag,\n        postTag: postTag,\n        highlightedValue: item.value\n      });\n    });\n  }\n\n  return parseHighlightedAttribute({\n    preTag: preTag,\n    postTag: postTag,\n    highlightedValue: highlightObject.value\n  });\n}","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport { omit } from './utils';\nexport function getIndexId(context) {\n  return hasMultipleIndices(context) ? context.multiIndexContext.targetedIndex : context.ais.mainTargetedIndex;\n}\nexport function getResults(searchResults, context) {\n  if (searchResults.results) {\n    if (searchResults.results.hits) {\n      return searchResults.results;\n    }\n\n    var indexId = getIndexId(context);\n\n    if (searchResults.results[indexId]) {\n      return searchResults.results[indexId];\n    }\n  }\n\n  return null;\n}\nexport function hasMultipleIndices(context) {\n  return context && context.multiIndexContext;\n} // eslint-disable-next-line max-params\n\nexport function refineValue(searchState, nextRefinement, context, resetPage, namespace) {\n  if (hasMultipleIndices(context)) {\n    var indexId = getIndexId(context);\n    return namespace ? refineMultiIndexWithNamespace(searchState, nextRefinement, indexId, resetPage, namespace) : refineMultiIndex(searchState, nextRefinement, indexId, resetPage);\n  } else {\n    // When we have a multi index page with shared widgets we should also\n    // reset their page to 1 if the resetPage is provided. Otherwise the\n    // indices will always be reset\n    // see: https://github.com/algolia/react-instantsearch/issues/310\n    // see: https://github.com/algolia/react-instantsearch/issues/637\n    if (searchState.indices && resetPage) {\n      Object.keys(searchState.indices).forEach(function (targetedIndex) {\n        searchState = refineValue(searchState, {\n          page: 1\n        }, {\n          multiIndexContext: {\n            targetedIndex: targetedIndex\n          }\n        }, true, namespace);\n      });\n    }\n\n    return namespace ? refineSingleIndexWithNamespace(searchState, nextRefinement, resetPage, namespace) : refineSingleIndex(searchState, nextRefinement, resetPage);\n  }\n}\n\nfunction refineMultiIndex(searchState, nextRefinement, indexId, resetPage) {\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  var state = searchState.indices && searchState.indices[indexId] ? _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread({}, searchState.indices[indexId], nextRefinement, page))) : _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread({}, nextRefinement, page)));\n  return _objectSpread({}, searchState, {\n    indices: state\n  });\n}\n\nfunction refineSingleIndex(searchState, nextRefinement, resetPage) {\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  return _objectSpread({}, searchState, nextRefinement, page);\n} // eslint-disable-next-line max-params\n\n\nfunction refineMultiIndexWithNamespace(searchState, nextRefinement, indexId, resetPage, namespace) {\n  var _objectSpread4;\n\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  var state = searchState.indices && searchState.indices[indexId] ? _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread({}, searchState.indices[indexId], (_objectSpread4 = {}, _defineProperty(_objectSpread4, namespace, _objectSpread({}, searchState.indices[indexId][namespace], nextRefinement)), _defineProperty(_objectSpread4, \"page\", 1), _objectSpread4)))) : _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread(_defineProperty({}, namespace, nextRefinement), page)));\n  return _objectSpread({}, searchState, {\n    indices: state\n  });\n}\n\nfunction refineSingleIndexWithNamespace(searchState, nextRefinement, resetPage, namespace) {\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  return _objectSpread({}, searchState, _defineProperty({}, namespace, _objectSpread({}, searchState[namespace], nextRefinement)), page);\n}\n\nfunction getNamespaceAndAttributeName(id) {\n  var parts = id.match(/^([^.]*)\\.(.*)/);\n  var namespace = parts && parts[1];\n  var attributeName = parts && parts[2];\n  return {\n    namespace: namespace,\n    attributeName: attributeName\n  };\n}\n\nfunction hasRefinements(_ref) {\n  var multiIndex = _ref.multiIndex,\n      indexId = _ref.indexId,\n      namespace = _ref.namespace,\n      attributeName = _ref.attributeName,\n      id = _ref.id,\n      searchState = _ref.searchState;\n\n  if (multiIndex && namespace) {\n    return searchState.indices && searchState.indices[indexId] && searchState.indices[indexId][namespace] && Object.hasOwnProperty.call(searchState.indices[indexId][namespace], attributeName);\n  }\n\n  if (multiIndex) {\n    return searchState.indices && searchState.indices[indexId] && Object.hasOwnProperty.call(searchState.indices[indexId], id);\n  }\n\n  if (namespace) {\n    return searchState[namespace] && Object.hasOwnProperty.call(searchState[namespace], attributeName);\n  }\n\n  return Object.hasOwnProperty.call(searchState, id);\n}\n\nfunction getRefinements(_ref2) {\n  var multiIndex = _ref2.multiIndex,\n      indexId = _ref2.indexId,\n      namespace = _ref2.namespace,\n      attributeName = _ref2.attributeName,\n      id = _ref2.id,\n      searchState = _ref2.searchState;\n\n  if (multiIndex && namespace) {\n    return searchState.indices[indexId][namespace][attributeName];\n  }\n\n  if (multiIndex) {\n    return searchState.indices[indexId][id];\n  }\n\n  if (namespace) {\n    return searchState[namespace][attributeName];\n  }\n\n  return searchState[id];\n}\n\nexport function getCurrentRefinementValue(props, searchState, context, id, defaultValue) {\n  var indexId = getIndexId(context);\n\n  var _getNamespaceAndAttri = getNamespaceAndAttributeName(id),\n      namespace = _getNamespaceAndAttri.namespace,\n      attributeName = _getNamespaceAndAttri.attributeName;\n\n  var multiIndex = hasMultipleIndices(context);\n  var args = {\n    multiIndex: multiIndex,\n    indexId: indexId,\n    namespace: namespace,\n    attributeName: attributeName,\n    id: id,\n    searchState: searchState\n  };\n  var hasRefinementsValue = hasRefinements(args);\n\n  if (hasRefinementsValue) {\n    return getRefinements(args);\n  }\n\n  if (props.defaultRefinement) {\n    return props.defaultRefinement;\n  }\n\n  return defaultValue;\n}\nexport function cleanUpValue(searchState, context, id) {\n  var indexId = getIndexId(context);\n\n  var _getNamespaceAndAttri2 = getNamespaceAndAttributeName(id),\n      namespace = _getNamespaceAndAttri2.namespace,\n      attributeName = _getNamespaceAndAttri2.attributeName;\n\n  if (hasMultipleIndices(context) && Boolean(searchState.indices)) {\n    return cleanUpValueWithMultiIndex({\n      attribute: attributeName,\n      searchState: searchState,\n      indexId: indexId,\n      id: id,\n      namespace: namespace\n    });\n  }\n\n  return cleanUpValueWithSingleIndex({\n    attribute: attributeName,\n    searchState: searchState,\n    id: id,\n    namespace: namespace\n  });\n}\n\nfunction cleanUpValueWithSingleIndex(_ref3) {\n  var searchState = _ref3.searchState,\n      id = _ref3.id,\n      namespace = _ref3.namespace,\n      attribute = _ref3.attribute;\n\n  if (namespace) {\n    return _objectSpread({}, searchState, _defineProperty({}, namespace, omit(searchState[namespace], [attribute])));\n  }\n\n  return omit(searchState, [id]);\n}\n\nfunction cleanUpValueWithMultiIndex(_ref4) {\n  var searchState = _ref4.searchState,\n      indexId = _ref4.indexId,\n      id = _ref4.id,\n      namespace = _ref4.namespace,\n      attribute = _ref4.attribute;\n  var indexSearchState = searchState.indices[indexId];\n\n  if (namespace && indexSearchState) {\n    return _objectSpread({}, searchState, {\n      indices: _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread({}, indexSearchState, _defineProperty({}, namespace, omit(indexSearchState[namespace], [attribute])))))\n    });\n  }\n\n  if (indexSearchState) {\n    return _objectSpread({}, searchState, {\n      indices: _objectSpread({}, searchState.indices, _defineProperty({}, indexId, omit(indexSearchState, [id])))\n    });\n  }\n\n  return searchState;\n}","import \"core-js/modules/es.array.reduce.js\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport algoliasearchHelper from 'algoliasearch-helper';\nimport createWidgetsManager from './createWidgetsManager';\nimport createStore from './createStore';\nimport { HIGHLIGHT_TAGS } from './highlight';\nimport { hasMultipleIndices } from './indexUtils';\nimport { version as ReactVersion } from 'react';\nimport version from './version';\n\nfunction addAlgoliaAgents(searchClient) {\n  if (typeof searchClient.addAlgoliaAgent === 'function') {\n    searchClient.addAlgoliaAgent(\"react (\".concat(ReactVersion, \")\"));\n    searchClient.addAlgoliaAgent(\"react-instantsearch (\".concat(version, \")\"));\n  }\n}\n\nvar isMultiIndexContext = function isMultiIndexContext(widget) {\n  return hasMultipleIndices({\n    ais: widget.props.contextValue,\n    multiIndexContext: widget.props.indexContextValue\n  });\n};\n\nvar isTargetedIndexEqualIndex = function isTargetedIndexEqualIndex(widget, indexId) {\n  return widget.props.indexContextValue.targetedIndex === indexId;\n}; // Relying on the `indexId` is a bit brittle to detect the `Index` widget.\n// Since it's a class we could rely on `instanceof` or similar. We never\n// had an issue though. Works for now.\n\n\nvar isIndexWidget = function isIndexWidget(widget) {\n  return Boolean(widget.props.indexId);\n};\n\nvar isIndexWidgetEqualIndex = function isIndexWidgetEqualIndex(widget, indexId) {\n  return widget.props.indexId === indexId;\n};\n\nvar sortIndexWidgetsFirst = function sortIndexWidgetsFirst(firstWidget, secondWidget) {\n  var isFirstWidgetIndex = isIndexWidget(firstWidget);\n  var isSecondWidgetIndex = isIndexWidget(secondWidget);\n\n  if (isFirstWidgetIndex && !isSecondWidgetIndex) {\n    return -1;\n  }\n\n  if (!isFirstWidgetIndex && isSecondWidgetIndex) {\n    return 1;\n  }\n\n  return 0;\n}; // This function is copied from the algoliasearch v4 API Client. If modified,\n// consider updating it also in `serializeQueryParameters` from `@algolia/transporter`.\n\n\nfunction serializeQueryParameters(parameters) {\n  var isObjectOrArray = function isObjectOrArray(value) {\n    return Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === '[object Array]';\n  };\n\n  var encode = function encode(format) {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    var i = 0;\n    return format.replace(/%s/g, function () {\n      return encodeURIComponent(args[i++]);\n    });\n  };\n\n  return Object.keys(parameters).map(function (key) {\n    return encode('%s=%s', key, isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key]);\n  }).join('&');\n}\n/**\n * Creates a new instance of the InstantSearchManager which controls the widgets and\n * trigger the search when the widgets are updated.\n * @param {string} indexName - the main index name\n * @param {object} initialState - initial widget state\n * @param {object} SearchParameters - optional additional parameters to send to the algolia API\n * @param {number} stalledSearchDelay - time (in ms) after the search is stalled\n * @return {InstantSearchManager} a new instance of InstantSearchManager\n */\n\n\nexport default function createInstantSearchManager(_ref) {\n  var indexName = _ref.indexName,\n      _ref$initialState = _ref.initialState,\n      initialState = _ref$initialState === void 0 ? {} : _ref$initialState,\n      searchClient = _ref.searchClient,\n      resultsState = _ref.resultsState,\n      stalledSearchDelay = _ref.stalledSearchDelay;\n  var helper = algoliasearchHelper(searchClient, indexName, _objectSpread({}, HIGHLIGHT_TAGS));\n  addAlgoliaAgents(searchClient);\n  helper.on('search', handleNewSearch).on('result', handleSearchSuccess({\n    indexId: indexName\n  })).on('error', handleSearchError);\n  var skip = false;\n  var stalledSearchTimer = null;\n  var initialSearchParameters = helper.state;\n  var widgetsManager = createWidgetsManager(onWidgetsUpdate);\n  hydrateSearchClient(searchClient, resultsState);\n  var store = createStore({\n    widgets: initialState,\n    metadata: hydrateMetadata(resultsState),\n    results: hydrateResultsState(resultsState),\n    error: null,\n    searching: false,\n    isSearchStalled: true,\n    searchingForFacetValues: false\n  });\n\n  function skipSearch() {\n    skip = true;\n  }\n\n  function updateClient(client) {\n    addAlgoliaAgents(client);\n    helper.setClient(client);\n    search();\n  }\n\n  function clearCache() {\n    helper.clearCache();\n    search();\n  }\n\n  function getMetadata(state) {\n    return widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getMetadata);\n    }).map(function (widget) {\n      return widget.getMetadata(state);\n    });\n  }\n\n  function getSearchParameters() {\n    var sharedParameters = widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getSearchParameters);\n    }).filter(function (widget) {\n      return !isMultiIndexContext(widget) && !isIndexWidget(widget);\n    }).reduce(function (res, widget) {\n      return widget.getSearchParameters(res);\n    }, initialSearchParameters);\n    var mainParameters = widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getSearchParameters);\n    }).filter(function (widget) {\n      var targetedIndexEqualMainIndex = isMultiIndexContext(widget) && isTargetedIndexEqualIndex(widget, indexName);\n      var subIndexEqualMainIndex = isIndexWidget(widget) && isIndexWidgetEqualIndex(widget, indexName);\n      return targetedIndexEqualMainIndex || subIndexEqualMainIndex;\n    }) // We have to sort the `Index` widgets first so the `index` parameter\n    // is correctly set in the `reduce` function for the following widgets\n    .sort(sortIndexWidgetsFirst).reduce(function (res, widget) {\n      return widget.getSearchParameters(res);\n    }, sharedParameters);\n    var derivedIndices = widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getSearchParameters);\n    }).filter(function (widget) {\n      var targetedIndexNotEqualMainIndex = isMultiIndexContext(widget) && !isTargetedIndexEqualIndex(widget, indexName);\n      var subIndexNotEqualMainIndex = isIndexWidget(widget) && !isIndexWidgetEqualIndex(widget, indexName);\n      return targetedIndexNotEqualMainIndex || subIndexNotEqualMainIndex;\n    }) // We have to sort the `Index` widgets first so the `index` parameter\n    // is correctly set in the `reduce` function for the following widgets\n    .sort(sortIndexWidgetsFirst).reduce(function (indices, widget) {\n      var indexId = isMultiIndexContext(widget) ? widget.props.indexContextValue.targetedIndex : widget.props.indexId;\n      var widgets = indices[indexId] || [];\n      return _objectSpread({}, indices, _defineProperty({}, indexId, widgets.concat(widget)));\n    }, {});\n    var derivedParameters = Object.keys(derivedIndices).map(function (indexId) {\n      return {\n        parameters: derivedIndices[indexId].reduce(function (res, widget) {\n          return widget.getSearchParameters(res);\n        }, sharedParameters),\n        indexId: indexId\n      };\n    });\n    return {\n      mainParameters: mainParameters,\n      derivedParameters: derivedParameters\n    };\n  }\n\n  function search() {\n    if (!skip) {\n      var _getSearchParameters = getSearchParameters(helper.state),\n          mainParameters = _getSearchParameters.mainParameters,\n          derivedParameters = _getSearchParameters.derivedParameters; // We have to call `slice` because the method `detach` on the derived\n      // helpers mutates the value `derivedHelpers`. The `forEach` loop does\n      // not iterate on each value and we're not able to correctly clear the\n      // previous derived helpers (memory leak + useless requests).\n\n\n      helper.derivedHelpers.slice().forEach(function (derivedHelper) {\n        // Since we detach the derived helpers on **every** new search they\n        // won't receive intermediate results in case of a stalled search.\n        // Only the last result is dispatched by the derived helper because\n        // they are not detached yet:\n        //\n        // - a -> main helper receives results\n        // - ap -> main helper receives results\n        // - app -> main helper + derived helpers receive results\n        //\n        // The quick fix is to avoid to detach them on search but only once they\n        // received the results. But it means that in case of a stalled search\n        // all the derived helpers not detached yet register a new search inside\n        // the helper. The number grows fast in case of a bad network and it's\n        // not deterministic.\n        derivedHelper.detach();\n      });\n      derivedParameters.forEach(function (_ref2) {\n        var indexId = _ref2.indexId,\n            parameters = _ref2.parameters;\n        var derivedHelper = helper.derive(function () {\n          return parameters;\n        });\n        derivedHelper.on('result', handleSearchSuccess({\n          indexId: indexId\n        })).on('error', handleSearchError);\n      });\n      helper.setState(mainParameters);\n      helper.search();\n    }\n  }\n\n  function handleSearchSuccess(_ref3) {\n    var indexId = _ref3.indexId;\n    return function (event) {\n      var state = store.getState();\n      var isDerivedHelpersEmpty = !helper.derivedHelpers.length;\n      var results = state.results ? state.results : {}; // Switching from mono index to multi index and vice versa must reset the\n      // results to an empty object, otherwise we keep reference of stalled and\n      // unused results.\n\n      results = !isDerivedHelpersEmpty && results.getFacetByName ? {} : results;\n\n      if (!isDerivedHelpersEmpty) {\n        results = _objectSpread({}, results, _defineProperty({}, indexId, event.results));\n      } else {\n        results = event.results;\n      }\n\n      var currentState = store.getState();\n      var nextIsSearchStalled = currentState.isSearchStalled;\n\n      if (!helper.hasPendingRequests()) {\n        clearTimeout(stalledSearchTimer);\n        stalledSearchTimer = null;\n        nextIsSearchStalled = false;\n      }\n\n      var resultsFacetValues = currentState.resultsFacetValues,\n          partialState = _objectWithoutProperties(currentState, [\"resultsFacetValues\"]);\n\n      store.setState(_objectSpread({}, partialState, {\n        results: results,\n        isSearchStalled: nextIsSearchStalled,\n        searching: false,\n        error: null\n      }));\n    };\n  }\n\n  function handleSearchError(_ref4) {\n    var error = _ref4.error;\n    var currentState = store.getState();\n    var nextIsSearchStalled = currentState.isSearchStalled;\n\n    if (!helper.hasPendingRequests()) {\n      clearTimeout(stalledSearchTimer);\n      nextIsSearchStalled = false;\n    }\n\n    var resultsFacetValues = currentState.resultsFacetValues,\n        partialState = _objectWithoutProperties(currentState, [\"resultsFacetValues\"]);\n\n    store.setState(_objectSpread({}, partialState, {\n      isSearchStalled: nextIsSearchStalled,\n      error: error,\n      searching: false\n    }));\n  }\n\n  function handleNewSearch() {\n    if (!stalledSearchTimer) {\n      stalledSearchTimer = setTimeout(function () {\n        var _store$getState = store.getState(),\n            resultsFacetValues = _store$getState.resultsFacetValues,\n            partialState = _objectWithoutProperties(_store$getState, [\"resultsFacetValues\"]);\n\n        store.setState(_objectSpread({}, partialState, {\n          isSearchStalled: true\n        }));\n      }, stalledSearchDelay);\n    }\n  }\n\n  function hydrateSearchClient(client, results) {\n    if (!results) {\n      return;\n    } // Disable cache hydration on:\n    // - Algoliasearch API Client < v4 with cache disabled\n    // - Third party clients (detected by the `addAlgoliaAgent` function missing)\n\n\n    if ((!client.transporter || client._cacheHydrated) && (!client._useCache || typeof client.addAlgoliaAgent !== 'function')) {\n      return;\n    } // Algoliasearch API Client >= v4\n    // To hydrate the client we need to populate the cache with the data from\n    // the server (done in `hydrateSearchClientWithMultiIndexRequest` or\n    // `hydrateSearchClientWithSingleIndexRequest`). But since there is no way\n    // for us to compute the key the same way as `algoliasearch-client` we need\n    // to populate it on a custom key and override the `search` method to\n    // search on it first.\n\n\n    if (client.transporter && !client._cacheHydrated) {\n      client._cacheHydrated = true;\n      var baseMethod = client.search;\n\n      client.search = function (requests) {\n        for (var _len2 = arguments.length, methodArgs = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n          methodArgs[_key2 - 1] = arguments[_key2];\n        }\n\n        var requestsWithSerializedParams = requests.map(function (request) {\n          return _objectSpread({}, request, {\n            params: serializeQueryParameters(request.params)\n          });\n        });\n        return client.transporter.responsesCache.get({\n          method: 'search',\n          args: [requestsWithSerializedParams].concat(methodArgs)\n        }, function () {\n          return baseMethod.apply(void 0, [requests].concat(methodArgs));\n        });\n      };\n    }\n\n    if (Array.isArray(results.results)) {\n      hydrateSearchClientWithMultiIndexRequest(client, results.results);\n      return;\n    }\n\n    hydrateSearchClientWithSingleIndexRequest(client, results);\n  }\n\n  function hydrateSearchClientWithMultiIndexRequest(client, results) {\n    // Algoliasearch API Client >= v4\n    // Populate the cache with the data from the server\n    if (client.transporter) {\n      client.transporter.responsesCache.set({\n        method: 'search',\n        args: [results.reduce(function (acc, result) {\n          return acc.concat(result.rawResults.map(function (request) {\n            return {\n              indexName: request.index,\n              params: request.params\n            };\n          }));\n        }, [])]\n      }, {\n        results: results.reduce(function (acc, result) {\n          return acc.concat(result.rawResults);\n        }, [])\n      });\n      return;\n    } // Algoliasearch API Client < v4\n    // Prior to client v4 we didn't have a proper API to hydrate the client\n    // cache from the outside. The following code populates the cache with\n    // a single-index result. You can find more information about the\n    // computation of the key inside the client (see link below).\n    // https://github.com/algolia/algoliasearch-client-javascript/blob/c27e89ff92b2a854ae6f40dc524bffe0f0cbc169/src/AlgoliaSearchCore.js#L232-L240\n\n\n    var key = \"/1/indexes/*/queries_body_\".concat(JSON.stringify({\n      requests: results.reduce(function (acc, result) {\n        return acc.concat(result.rawResults.map(function (request) {\n          return {\n            indexName: request.index,\n            params: request.params\n          };\n        }));\n      }, [])\n    }));\n    client.cache = _objectSpread({}, client.cache, _defineProperty({}, key, JSON.stringify({\n      results: results.reduce(function (acc, result) {\n        return acc.concat(result.rawResults);\n      }, [])\n    })));\n  }\n\n  function hydrateSearchClientWithSingleIndexRequest(client, results) {\n    // Algoliasearch API Client >= v4\n    // Populate the cache with the data from the server\n    if (client.transporter) {\n      client.transporter.responsesCache.set({\n        method: 'search',\n        args: [results.rawResults.map(function (request) {\n          return {\n            indexName: request.index,\n            params: request.params\n          };\n        })]\n      }, {\n        results: results.rawResults\n      });\n      return;\n    } // Algoliasearch API Client < v4\n    // Prior to client v4 we didn't have a proper API to hydrate the client\n    // cache from the outside. The following code populates the cache with\n    // a single-index result. You can find more information about the\n    // computation of the key inside the client (see link below).\n    // https://github.com/algolia/algoliasearch-client-javascript/blob/c27e89ff92b2a854ae6f40dc524bffe0f0cbc169/src/AlgoliaSearchCore.js#L232-L240\n\n\n    var key = \"/1/indexes/*/queries_body_\".concat(JSON.stringify({\n      requests: results.rawResults.map(function (request) {\n        return {\n          indexName: request.index,\n          params: request.params\n        };\n      })\n    }));\n    client.cache = _objectSpread({}, client.cache, _defineProperty({}, key, JSON.stringify({\n      results: results.rawResults\n    })));\n  }\n\n  function hydrateResultsState(results) {\n    if (!results) {\n      return null;\n    }\n\n    if (Array.isArray(results.results)) {\n      return results.results.reduce(function (acc, result) {\n        return _objectSpread({}, acc, _defineProperty({}, result._internalIndexId, new algoliasearchHelper.SearchResults(new algoliasearchHelper.SearchParameters(result.state), result.rawResults)));\n      }, {});\n    }\n\n    return new algoliasearchHelper.SearchResults(new algoliasearchHelper.SearchParameters(results.state), results.rawResults);\n  } // Called whenever a widget has been rendered with new props.\n\n\n  function onWidgetsUpdate() {\n    var metadata = getMetadata(store.getState().widgets);\n    store.setState(_objectSpread({}, store.getState(), {\n      metadata: metadata,\n      searching: true\n    })); // Since the `getSearchParameters` method of widgets also depends on props,\n    // the result search parameters might have changed.\n\n    search();\n  }\n\n  function transitionState(nextSearchState) {\n    var searchState = store.getState().widgets;\n    return widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.transitionState);\n    }).reduce(function (res, widget) {\n      return widget.transitionState(searchState, res);\n    }, nextSearchState);\n  }\n\n  function onExternalStateUpdate(nextSearchState) {\n    var metadata = getMetadata(nextSearchState);\n    store.setState(_objectSpread({}, store.getState(), {\n      widgets: nextSearchState,\n      metadata: metadata,\n      searching: true\n    }));\n    search();\n  }\n\n  function onSearchForFacetValues(_ref5) {\n    var facetName = _ref5.facetName,\n        query = _ref5.query,\n        _ref5$maxFacetHits = _ref5.maxFacetHits,\n        maxFacetHits = _ref5$maxFacetHits === void 0 ? 10 : _ref5$maxFacetHits; // The values 1, 100 are the min / max values that the engine accepts.\n    // see: https://www.algolia.com/doc/api-reference/api-parameters/maxFacetHits\n\n    var maxFacetHitsWithinRange = Math.max(1, Math.min(maxFacetHits, 100));\n    store.setState(_objectSpread({}, store.getState(), {\n      searchingForFacetValues: true\n    }));\n    helper.searchForFacetValues(facetName, query, maxFacetHitsWithinRange).then(function (content) {\n      var _objectSpread7;\n\n      store.setState(_objectSpread({}, store.getState(), {\n        error: null,\n        searchingForFacetValues: false,\n        resultsFacetValues: _objectSpread({}, store.getState().resultsFacetValues, (_objectSpread7 = {}, _defineProperty(_objectSpread7, facetName, content.facetHits), _defineProperty(_objectSpread7, \"query\", query), _objectSpread7))\n      }));\n    }, function (error) {\n      store.setState(_objectSpread({}, store.getState(), {\n        searchingForFacetValues: false,\n        error: error\n      }));\n    }).catch(function (error) {\n      // Since setState is synchronous, any error that occurs in the render of a\n      // component will be swallowed by this promise.\n      // This is a trick to make the error show up correctly in the console.\n      // See http://stackoverflow.com/a/30741722/969302\n      setTimeout(function () {\n        throw error;\n      });\n    });\n  }\n\n  function updateIndex(newIndex) {\n    initialSearchParameters = initialSearchParameters.setIndex(newIndex); // No need to trigger a new search here as the widgets will also update and trigger it if needed.\n  }\n\n  function getWidgetsIds() {\n    return store.getState().metadata.reduce(function (res, meta) {\n      return typeof meta.id !== 'undefined' ? res.concat(meta.id) : res;\n    }, []);\n  }\n\n  return {\n    store: store,\n    widgetsManager: widgetsManager,\n    getWidgetsIds: getWidgetsIds,\n    getSearchParameters: getSearchParameters,\n    onSearchForFacetValues: onSearchForFacetValues,\n    onExternalStateUpdate: onExternalStateUpdate,\n    transitionState: transitionState,\n    updateClient: updateClient,\n    updateIndex: updateIndex,\n    clearCache: clearCache,\n    skipSearch: skipSearch\n  };\n}\n\nfunction hydrateMetadata(resultsState) {\n  if (!resultsState) {\n    return [];\n  } // add a value noop, which gets replaced once the widgets are mounted\n\n\n  return resultsState.metadata.map(function (datum) {\n    return _objectSpread({\n      value: function value() {}\n    }, datum, {\n      items: datum.items && datum.items.map(function (item) {\n        return _objectSpread({\n          value: function value() {}\n        }, item, {\n          items: item.items && item.items.map(function (nestedItem) {\n            return _objectSpread({\n              value: function value() {}\n            }, nestedItem);\n          })\n        });\n      })\n    });\n  });\n}","export default '6.8.3';","export default function createStore(initialState) {\n  var state = initialState;\n  var listeners = [];\n  return {\n    getState: function getState() {\n      return state;\n    },\n    setState: function setState(nextState) {\n      state = nextState;\n      listeners.forEach(function (listener) {\n        return listener();\n      });\n    },\n    subscribe: function subscribe(listener) {\n      listeners.push(listener);\n      return function unsubscribe() {\n        listeners.splice(listeners.indexOf(listener), 1);\n      };\n    }\n  };\n}","import { createContext } from 'react';\n\nvar _createContext = createContext({\n  onInternalStateUpdate: function onInternalStateUpdate() {\n    return undefined;\n  },\n  createHrefForState: function createHrefForState() {\n    return '#';\n  },\n  onSearchForFacetValues: function onSearchForFacetValues() {\n    return undefined;\n  },\n  onSearchStateChange: function onSearchStateChange() {\n    return undefined;\n  },\n  onSearchParameters: function onSearchParameters() {\n    return undefined;\n  },\n  store: {},\n  widgetsManager: {},\n  mainTargetedIndex: ''\n}),\n    InstantSearchConsumer = _createContext.Consumer,\n    InstantSearchProvider = _createContext.Provider;\n\nexport { InstantSearchConsumer, InstantSearchProvider };\n\nvar _createContext2 = createContext(undefined),\n    IndexConsumer = _createContext2.Consumer,\n    IndexProvider = _createContext2.Provider;\n\nexport { IndexConsumer, IndexProvider };","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport React, { Component, Children } from 'react';\nimport isEqual from 'react-fast-compare';\nimport PropTypes from 'prop-types';\nimport createInstantSearchManager from '../core/createInstantSearchManager';\nimport { InstantSearchProvider } from '../core/context';\n\nfunction isControlled(props) {\n  return Boolean(props.searchState);\n}\n/**\n * @description\n * `<InstantSearch>` is the root component of all React InstantSearch implementations.\n * It provides all the connected components (aka widgets) a means to interact\n * with the searchState.\n * @kind widget\n * @name <InstantSearch>\n * @requirements You will need to have an Algolia account to be able to use this widget.\n * [Create one now](https://www.algolia.com/users/sign_up).\n * @propType {string} indexName - Main index in which to search.\n * @propType {boolean} [refresh=false] - Flag to activate when the cache needs to be cleared so that the front-end is updated when a change occurs in the index.\n * @propType {object} [searchClient] - Provide a custom search client.\n * @propType {func} [onSearchStateChange] - Function to be called everytime a new search is done. Useful for [URL Routing](guide/Routing.html).\n * @propType {object} [searchState] - Object to inject some search state. Switches the InstantSearch component in controlled mode. Useful for [URL Routing](guide/Routing.html).\n * @propType {func} [createURL] - Function to call when creating links, useful for [URL Routing](guide/Routing.html).\n * @propType {SearchResults|SearchResults[]} [resultsState] - Use this to inject the results that will be used at first rendering. Those results are found by using the `findResultsState` function. Useful for [Server Side Rendering](guide/Server-side_rendering.html).\n * @propType {number} [stalledSearchDelay=200] - The amount of time before considering that the search takes too much time. The time is expressed in milliseconds.\n * @propType {{ Root: string|function, props: object }} [root] - Use this to customize the root element. Default value: `{ Root: 'div' }`\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, SearchBox, Hits } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <SearchBox />\n *     <Hits />\n *   </InstantSearch>\n * );\n */\n\n\nvar InstantSearch = /*#__PURE__*/function (_Component) {\n  _inherits(InstantSearch, _Component);\n\n  _createClass(InstantSearch, null, [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      var nextIsControlled = isControlled(nextProps);\n      var previousSearchState = prevState.instantSearchManager.store.getState().widgets;\n      var nextSearchState = nextProps.searchState;\n\n      if (nextIsControlled && !isEqual(previousSearchState, nextSearchState)) {\n        prevState.instantSearchManager.onExternalStateUpdate(nextProps.searchState);\n      }\n\n      return {\n        isControlled: nextIsControlled,\n        contextValue: _objectSpread({}, prevState.contextValue, {\n          mainTargetedIndex: nextProps.indexName\n        })\n      };\n    }\n  }]);\n\n  function InstantSearch(props) {\n    var _this;\n\n    _classCallCheck(this, InstantSearch);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(InstantSearch).call(this, props));\n\n    _defineProperty(_assertThisInitialized(_this), \"isUnmounting\", false);\n\n    var instantSearchManager = createInstantSearchManager({\n      indexName: _this.props.indexName,\n      searchClient: _this.props.searchClient,\n      initialState: _this.props.searchState || {},\n      resultsState: _this.props.resultsState,\n      stalledSearchDelay: _this.props.stalledSearchDelay\n    });\n    var contextValue = {\n      store: instantSearchManager.store,\n      widgetsManager: instantSearchManager.widgetsManager,\n      mainTargetedIndex: _this.props.indexName,\n      onInternalStateUpdate: _this.onWidgetsInternalStateUpdate.bind(_assertThisInitialized(_this)),\n      createHrefForState: _this.createHrefForState.bind(_assertThisInitialized(_this)),\n      onSearchForFacetValues: _this.onSearchForFacetValues.bind(_assertThisInitialized(_this)),\n      onSearchStateChange: _this.onSearchStateChange.bind(_assertThisInitialized(_this)),\n      onSearchParameters: _this.onSearchParameters.bind(_assertThisInitialized(_this))\n    };\n    _this.state = {\n      isControlled: isControlled(_this.props),\n      instantSearchManager: instantSearchManager,\n      contextValue: contextValue\n    };\n    return _this;\n  }\n\n  _createClass(InstantSearch, [{\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps) {\n      var prevIsControlled = isControlled(prevProps);\n\n      if (prevIsControlled && !this.state.isControlled) {\n        throw new Error(\"You can't switch <InstantSearch> from being controlled to uncontrolled\");\n      }\n\n      if (!prevIsControlled && this.state.isControlled) {\n        throw new Error(\"You can't switch <InstantSearch> from being uncontrolled to controlled\");\n      }\n\n      if (this.props.refresh !== prevProps.refresh && this.props.refresh) {\n        this.state.instantSearchManager.clearCache();\n      }\n\n      if (prevProps.indexName !== this.props.indexName) {\n        this.state.instantSearchManager.updateIndex(this.props.indexName);\n      }\n\n      if (prevProps.searchClient !== this.props.searchClient) {\n        this.state.instantSearchManager.updateClient(this.props.searchClient);\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this.isUnmounting = true;\n      this.state.instantSearchManager.skipSearch();\n    }\n  }, {\n    key: \"createHrefForState\",\n    value: function createHrefForState(searchState) {\n      searchState = this.state.instantSearchManager.transitionState(searchState);\n      return this.state.isControlled && this.props.createURL ? this.props.createURL(searchState, this.getKnownKeys()) : '#';\n    }\n  }, {\n    key: \"onWidgetsInternalStateUpdate\",\n    value: function onWidgetsInternalStateUpdate(searchState) {\n      searchState = this.state.instantSearchManager.transitionState(searchState);\n      this.onSearchStateChange(searchState);\n\n      if (!this.state.isControlled) {\n        this.state.instantSearchManager.onExternalStateUpdate(searchState);\n      }\n    }\n  }, {\n    key: \"onSearchStateChange\",\n    value: function onSearchStateChange(searchState) {\n      if (this.props.onSearchStateChange && !this.isUnmounting) {\n        this.props.onSearchStateChange(searchState);\n      }\n    }\n  }, {\n    key: \"onSearchParameters\",\n    value: function onSearchParameters(getSearchParameters, context, props, getMetadata) {\n      if (this.props.onSearchParameters) {\n        var _searchState = this.props.searchState ? this.props.searchState : {};\n\n        this.props.onSearchParameters(getSearchParameters, context, props, _searchState);\n      }\n\n      if (this.props.widgetsCollector) {\n        var _searchState2 = this.props.searchState ? this.props.searchState : {};\n\n        this.props.widgetsCollector({\n          getSearchParameters: getSearchParameters,\n          getMetadata: getMetadata,\n          context: context,\n          props: props,\n          searchState: _searchState2\n        });\n      }\n    }\n  }, {\n    key: \"onSearchForFacetValues\",\n    value: function onSearchForFacetValues(searchState) {\n      this.state.instantSearchManager.onSearchForFacetValues(searchState);\n    }\n  }, {\n    key: \"getKnownKeys\",\n    value: function getKnownKeys() {\n      return this.state.instantSearchManager.getWidgetsIds();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      if (Children.count(this.props.children) === 0) {\n        return null;\n      }\n\n      return React.createElement(InstantSearchProvider, {\n        value: this.state.contextValue\n      }, this.props.children);\n    }\n  }]);\n\n  return InstantSearch;\n}(Component);\n\n_defineProperty(InstantSearch, \"defaultProps\", {\n  stalledSearchDelay: 200,\n  refresh: false\n});\n\n_defineProperty(InstantSearch, \"propTypes\", {\n  // @TODO: These props are currently constant.\n  indexName: PropTypes.string.isRequired,\n  searchClient: PropTypes.shape({\n    search: PropTypes.func.isRequired,\n    searchForFacetValues: PropTypes.func,\n    addAlgoliaAgent: PropTypes.func,\n    clearCache: PropTypes.func\n  }).isRequired,\n  createURL: PropTypes.func,\n  refresh: PropTypes.bool,\n  searchState: PropTypes.object,\n  onSearchStateChange: PropTypes.func,\n  onSearchParameters: PropTypes.func,\n  widgetsCollector: PropTypes.func,\n  resultsState: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),\n  children: PropTypes.node,\n  stalledSearchDelay: PropTypes.number\n});\n\nexport default InstantSearch;","export default function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport React, { Component } from 'react';\nimport isEqual from 'react-fast-compare';\nimport { shallowEqual, getDisplayName, removeEmptyKey } from './utils';\nimport { InstantSearchConsumer, IndexConsumer } from './context';\n/**\n * Connectors are the HOC used to transform React components\n * into InstantSearch widgets.\n * In order to simplify the construction of such connectors\n * `createConnector` takes a description and transform it into\n * a connector.\n * @param {ConnectorDescription} connectorDesc the description of the connector\n * @return {Connector} a function that wraps a component into\n * an instantsearch connected one.\n */\n\nexport function createConnectorWithoutContext(connectorDesc) {\n  if (!connectorDesc.displayName) {\n    throw new Error('`createConnector` requires you to provide a `displayName` property.');\n  }\n\n  var isWidget = typeof connectorDesc.getSearchParameters === 'function' || typeof connectorDesc.getMetadata === 'function' || typeof connectorDesc.transitionState === 'function';\n  return function (Composed) {\n    var Connector = /*#__PURE__*/function (_Component) {\n      _inherits(Connector, _Component);\n\n      function Connector(props) {\n        var _this;\n\n        _classCallCheck(this, Connector);\n\n        _this = _possibleConstructorReturn(this, _getPrototypeOf(Connector).call(this, props));\n\n        _defineProperty(_assertThisInitialized(_this), \"unsubscribe\", void 0);\n\n        _defineProperty(_assertThisInitialized(_this), \"unregisterWidget\", void 0);\n\n        _defineProperty(_assertThisInitialized(_this), \"isUnmounting\", false);\n\n        _defineProperty(_assertThisInitialized(_this), \"state\", {\n          providedProps: _this.getProvidedProps(_this.props)\n        });\n\n        _defineProperty(_assertThisInitialized(_this), \"refine\", function () {\n          var _ref;\n\n          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n            args[_key] = arguments[_key];\n          }\n\n          _this.props.contextValue.onInternalStateUpdate( // refine will always be defined here because the prop is only given conditionally\n          (_ref = connectorDesc.refine).call.apply(_ref, [_assertThisInitialized(_this), _this.props, _this.props.contextValue.store.getState().widgets].concat(args)));\n        });\n\n        _defineProperty(_assertThisInitialized(_this), \"createURL\", function () {\n          var _ref2;\n\n          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n            args[_key2] = arguments[_key2];\n          }\n\n          return _this.props.contextValue.createHrefForState( // refine will always be defined here because the prop is only given conditionally\n          (_ref2 = connectorDesc.refine).call.apply(_ref2, [_assertThisInitialized(_this), _this.props, _this.props.contextValue.store.getState().widgets].concat(args)));\n        });\n\n        _defineProperty(_assertThisInitialized(_this), \"searchForFacetValues\", function () {\n          var _ref3;\n\n          for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n            args[_key3] = arguments[_key3];\n          }\n\n          _this.props.contextValue.onSearchForFacetValues( // searchForFacetValues will always be defined here because the prop is only given conditionally\n          (_ref3 = connectorDesc.searchForFacetValues).call.apply(_ref3, [_assertThisInitialized(_this), _this.props, _this.props.contextValue.store.getState().widgets].concat(args)));\n        });\n\n        if (connectorDesc.getSearchParameters) {\n          _this.props.contextValue.onSearchParameters(connectorDesc.getSearchParameters.bind(_assertThisInitialized(_this)), {\n            ais: _this.props.contextValue,\n            multiIndexContext: _this.props.indexContextValue\n          }, _this.props, connectorDesc.getMetadata && connectorDesc.getMetadata.bind(_assertThisInitialized(_this)));\n        }\n\n        return _this;\n      }\n\n      _createClass(Connector, [{\n        key: \"componentDidMount\",\n        value: function componentDidMount() {\n          var _this2 = this;\n\n          this.unsubscribe = this.props.contextValue.store.subscribe(function () {\n            if (!_this2.isUnmounting) {\n              _this2.setState({\n                providedProps: _this2.getProvidedProps(_this2.props)\n              });\n            }\n          });\n\n          if (isWidget) {\n            this.unregisterWidget = this.props.contextValue.widgetsManager.registerWidget(this);\n          }\n        }\n      }, {\n        key: \"shouldComponentUpdate\",\n        value: function shouldComponentUpdate(nextProps, nextState) {\n          if (typeof connectorDesc.shouldComponentUpdate === 'function') {\n            return connectorDesc.shouldComponentUpdate.call(this, this.props, nextProps, this.state, nextState);\n          }\n\n          var propsEqual = shallowEqual(this.props, nextProps);\n\n          if (this.state.providedProps === null || nextState.providedProps === null) {\n            if (this.state.providedProps === nextState.providedProps) {\n              return !propsEqual;\n            }\n\n            return true;\n          }\n\n          return !propsEqual || !shallowEqual(this.state.providedProps, nextState.providedProps);\n        }\n      }, {\n        key: \"componentDidUpdate\",\n        value: function componentDidUpdate(prevProps) {\n          if (!isEqual(prevProps, this.props)) {\n            this.setState({\n              providedProps: this.getProvidedProps(this.props)\n            });\n\n            if (isWidget) {\n              this.props.contextValue.widgetsManager.update();\n\n              if (typeof connectorDesc.transitionState === 'function') {\n                this.props.contextValue.onSearchStateChange(connectorDesc.transitionState.call(this, this.props, this.props.contextValue.store.getState().widgets, this.props.contextValue.store.getState().widgets));\n              }\n            }\n          }\n        }\n      }, {\n        key: \"componentWillUnmount\",\n        value: function componentWillUnmount() {\n          this.isUnmounting = true;\n\n          if (this.unsubscribe) {\n            this.unsubscribe();\n          }\n\n          if (this.unregisterWidget) {\n            this.unregisterWidget();\n\n            if (typeof connectorDesc.cleanUp === 'function') {\n              var nextState = connectorDesc.cleanUp.call(this, this.props, this.props.contextValue.store.getState().widgets);\n              this.props.contextValue.store.setState(_objectSpread({}, this.props.contextValue.store.getState(), {\n                widgets: nextState\n              }));\n              this.props.contextValue.onSearchStateChange(removeEmptyKey(nextState));\n            }\n          }\n        }\n      }, {\n        key: \"getProvidedProps\",\n        value: function getProvidedProps(props) {\n          var _this$props$contextVa = this.props.contextValue.store.getState(),\n              widgets = _this$props$contextVa.widgets,\n              results = _this$props$contextVa.results,\n              resultsFacetValues = _this$props$contextVa.resultsFacetValues,\n              searching = _this$props$contextVa.searching,\n              searchingForFacetValues = _this$props$contextVa.searchingForFacetValues,\n              isSearchStalled = _this$props$contextVa.isSearchStalled,\n              metadata = _this$props$contextVa.metadata,\n              error = _this$props$contextVa.error;\n\n          var searchResults = {\n            results: results,\n            searching: searching,\n            searchingForFacetValues: searchingForFacetValues,\n            isSearchStalled: isSearchStalled,\n            error: error\n          };\n          return connectorDesc.getProvidedProps.call(this, props, widgets, searchResults, metadata, // @MAJOR: move this attribute on the `searchResults` it doesn't\n          // makes sense to have it into a separate argument. The search\n          // flags are on the object why not the results?\n          resultsFacetValues);\n        }\n      }, {\n        key: \"getSearchParameters\",\n        value: function getSearchParameters(searchParameters) {\n          if (typeof connectorDesc.getSearchParameters === 'function') {\n            return connectorDesc.getSearchParameters.call(this, searchParameters, this.props, this.props.contextValue.store.getState().widgets);\n          }\n\n          return null;\n        }\n      }, {\n        key: \"getMetadata\",\n        value: function getMetadata(nextWidgetsState) {\n          if (typeof connectorDesc.getMetadata === 'function') {\n            return connectorDesc.getMetadata.call(this, this.props, nextWidgetsState);\n          }\n\n          return {};\n        }\n      }, {\n        key: \"transitionState\",\n        value: function transitionState(prevWidgetsState, nextWidgetsState) {\n          if (typeof connectorDesc.transitionState === 'function') {\n            return connectorDesc.transitionState.call(this, this.props, prevWidgetsState, nextWidgetsState);\n          }\n\n          return nextWidgetsState;\n        }\n      }, {\n        key: \"render\",\n        value: function render() {\n          var _this$props = this.props,\n              contextValue = _this$props.contextValue,\n              props = _objectWithoutProperties(_this$props, [\"contextValue\"]);\n\n          var providedProps = this.state.providedProps;\n\n          if (providedProps === null) {\n            return null;\n          }\n\n          var refineProps = typeof connectorDesc.refine === 'function' ? {\n            refine: this.refine,\n            createURL: this.createURL\n          } : {};\n          var searchForFacetValuesProps = typeof connectorDesc.searchForFacetValues === 'function' ? {\n            searchForItems: this.searchForFacetValues\n          } : {};\n          return React.createElement(Composed, _extends({}, props, providedProps, refineProps, searchForFacetValuesProps));\n        }\n      }]);\n\n      return Connector;\n    }(Component);\n\n    _defineProperty(Connector, \"displayName\", \"\".concat(connectorDesc.displayName, \"(\").concat(getDisplayName(Composed), \")\"));\n\n    _defineProperty(Connector, \"propTypes\", connectorDesc.propTypes);\n\n    _defineProperty(Connector, \"defaultProps\", connectorDesc.defaultProps);\n\n    return Connector;\n  };\n}\n\nvar createConnectorWithContext = function createConnectorWithContext(connectorDesc) {\n  return function (Composed) {\n    var Connector = createConnectorWithoutContext(connectorDesc)(Composed);\n\n    var ConnectorWrapper = function ConnectorWrapper(props) {\n      return React.createElement(InstantSearchConsumer, null, function (contextValue) {\n        return React.createElement(IndexConsumer, null, function (indexContextValue) {\n          return React.createElement(Connector, _extends({\n            contextValue: contextValue,\n            indexContextValue: indexContextValue\n          }, props));\n        });\n      });\n    };\n\n    return ConnectorWrapper;\n  };\n};\n\nexport default createConnectorWithContext;","import \"core-js/modules/es.array.reduce.js\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport { omit } from '../core/utils';\nimport createConnector from '../core/createConnector';\nimport { refineValue, getIndexId, hasMultipleIndices } from '../core/indexUtils';\n\nfunction getId() {\n  return 'configure';\n}\n\nexport default createConnector({\n  displayName: 'AlgoliaConfigure',\n  getProvidedProps: function getProvidedProps() {\n    return {};\n  },\n  getSearchParameters: function getSearchParameters(searchParameters, props) {\n    var children = props.children,\n        contextValue = props.contextValue,\n        indexContextValue = props.indexContextValue,\n        items = _objectWithoutProperties(props, [\"children\", \"contextValue\", \"indexContextValue\"]);\n\n    return searchParameters.setQueryParameters(items);\n  },\n  transitionState: function transitionState(props, prevSearchState, nextSearchState) {\n    var id = getId();\n\n    var children = props.children,\n        contextValue = props.contextValue,\n        indexContextValue = props.indexContextValue,\n        items = _objectWithoutProperties(props, [\"children\", \"contextValue\", \"indexContextValue\"]);\n\n    var propKeys = Object.keys(props);\n    var nonPresentKeys = this._props ? Object.keys(this._props).filter(function (prop) {\n      return propKeys.indexOf(prop) === -1;\n    }) : [];\n    this._props = props;\n\n    var nextValue = _defineProperty({}, id, _objectSpread({}, omit(nextSearchState[id], nonPresentKeys), items));\n\n    return refineValue(nextSearchState, nextValue, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  },\n  cleanUp: function cleanUp(props, searchState) {\n    var id = getId();\n    var indexId = getIndexId({\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n    var subState = hasMultipleIndices({\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    }) && searchState.indices ? searchState.indices[indexId] : searchState;\n    var configureKeys = subState && subState[id] ? Object.keys(subState[id]) : [];\n    var configureState = configureKeys.reduce(function (acc, item) {\n      if (!props[item]) {\n        acc[item] = subState[id][item];\n      }\n\n      return acc;\n    }, {});\n\n    var nextValue = _defineProperty({}, id, configureState);\n\n    return refineValue(searchState, nextValue, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  }\n});","import connectConfigure from '../connectors/connectConfigure';\n/**\n * Configure is a widget that lets you provide raw search parameters\n * to the Algolia API.\n *\n * Any of the props added to this widget will be forwarded to Algolia. For more information\n * on the different parameters that can be set, have a look at the\n * [reference](https://www.algolia.com/doc/api-client/javascript/search#search-parameters).\n *\n * This widget can be used either with react-dom and react-native. It will not render anything\n * on screen, only configure some parameters.\n *\n * Read more in the [Search parameters](guide/Search_parameters.html) guide.\n * @name Configure\n * @kind widget\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, Configure, Hits } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <Configure hitsPerPage={5} />\n *     <Hits />\n *   </InstantSearch>\n * );\n */\n\nexport default connectConfigure(function Configure() {\n  return null;\n});","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport PropTypes from 'prop-types';\nimport createConnector from '../core/createConnector';\nimport { cleanUpValue, refineValue, getCurrentRefinementValue, getIndexId } from '../core/indexUtils';\n\nfunction getId() {\n  return 'query';\n}\n\nfunction getCurrentRefinement(props, searchState, context) {\n  var id = getId(props);\n  var currentRefinement = getCurrentRefinementValue(props, searchState, context, id, '');\n\n  if (currentRefinement) {\n    return currentRefinement;\n  }\n\n  return '';\n}\n\nfunction _refine(props, searchState, nextRefinement, context) {\n  var id = getId();\n\n  var nextValue = _defineProperty({}, id, nextRefinement);\n\n  var resetPage = true;\n  return refineValue(searchState, nextValue, context, resetPage);\n}\n\nfunction _cleanUp(props, searchState, context) {\n  return cleanUpValue(searchState, context, getId());\n}\n/**\n * connectSearchBox connector provides the logic to build a widget that will\n * let the user search for a query\n * @name connectSearchBox\n * @kind connector\n * @propType {string} [defaultRefinement] - Provide a default value for the query\n * @providedPropType {function} refine - a function to change the current query\n * @providedPropType {string} currentRefinement - the current query used\n * @providedPropType {boolean} isSearchStalled - a flag that indicates if InstantSearch has detected that searches are stalled\n */\n\n\nexport default createConnector({\n  displayName: 'AlgoliaSearchBox',\n  propTypes: {\n    defaultRefinement: PropTypes.string\n  },\n  getProvidedProps: function getProvidedProps(props, searchState, searchResults) {\n    return {\n      currentRefinement: getCurrentRefinement(props, searchState, {\n        ais: props.contextValue,\n        multiIndexContext: props.indexContextValue\n      }),\n      isSearchStalled: searchResults.isSearchStalled\n    };\n  },\n  refine: function refine(props, searchState, nextRefinement) {\n    return _refine(props, searchState, nextRefinement, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  },\n  cleanUp: function cleanUp(props, searchState) {\n    return _cleanUp(props, searchState, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  },\n  getSearchParameters: function getSearchParameters(searchParameters, props, searchState) {\n    return searchParameters.setQuery(getCurrentRefinement(props, searchState, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    }));\n  },\n  getMetadata: function getMetadata(props, searchState) {\n    var id = getId(props);\n    var currentRefinement = getCurrentRefinement(props, searchState, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n    return {\n      id: id,\n      index: getIndexId({\n        ais: props.contextValue,\n        multiIndexContext: props.indexContextValue\n      }),\n      items: currentRefinement === null ? [] : [{\n        label: \"\".concat(id, \": \").concat(currentRefinement),\n        value: function value(nextState) {\n          return _refine(props, nextState, '', {\n            ais: props.contextValue,\n            multiIndexContext: props.indexContextValue\n          });\n        },\n        currentRefinement: currentRefinement\n      }]\n    };\n  }\n});","import React from \"react\";\r\nimport { connectSearchBox } from \"react-instantsearch-dom\";\r\n\r\nexport default connectSearchBox(\r\n  ({ refine, currentRefinement, onFocus, hasFocus }) => (\r\n    <form className=\"flex flex-row-reverse items-center\">\r\n      <input\r\n        className={`py-1 pr-6 pl-2 transition-all ${\r\n          hasFocus ? \"w-64 outline-subtle\" : \"w-32 outline-none cursor-pointer\"\r\n        }`}\r\n        type=\"text\"\r\n        placeholder=\"Search\"\r\n        aria-label=\"Search\"\r\n        onChange={e => refine(e.target.value)}\r\n        value={currentRefinement}\r\n        onFocus={onFocus}\r\n      />\r\n      <svg\r\n        viewBox=\"0 0 24 24\"\r\n        height=\"24\"\r\n        width=\"24\"\r\n        className=\"absolute w-5 m-1 pointer-events-none\"\r\n      >\r\n        <path d=\"M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z\" />\r\n      </svg>\r\n    </form>\r\n  )\r\n);\r\n","import createConnector from '../core/createConnector';\nimport { getResults } from '../core/indexUtils';\n/**\n * The `connectStateResults` connector provides a way to access the `searchState` and the `searchResults`\n * of InstantSearch.\n * For instance this connector allows you to create results/noResults or query/noQuery pages.\n * @name connectStateResults\n * @kind connector\n * @providedPropType {object} searchState - The search state of the instant search component. <br/><br/> See: [Search state structure](https://community.algolia.com/react-instantsearch/guide/Search_state.html)\n * @providedPropType {object} searchResults - The search results. <br/><br/> In case of multiple indices: if used under `<Index>`, results will be those of the corresponding index otherwise it'll be those of the root index  See: [Search results structure](https://community.algolia.com/algoliasearch-helper-js/reference.html#searchresults)\n * @providedPropType {object} allSearchResults - In case of multiple indices you can retrieve all the results\n * @providedPropType {string} error - If the search failed, the error will be logged here.\n * @providedPropType {boolean} searching - If there is a search in progress.\n * @providedPropType {boolean} isSearchStalled - Flag that indicates if React InstantSearch has detected that searches are stalled.\n * @providedPropType {boolean} searchingForFacetValues - If there is a search in a list in progress.\n * @providedPropType {object} props - component props.\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, SearchBox, Hits, connectStateResults } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const Content = connectStateResults(({ searchState, searchResults }) => {\n *   const hasResults = searchResults && searchResults.nbHits !== 0;\n *\n *    return (\n *      <div>\n *        <div hidden={!hasResults}>\n *          <Hits />\n *        </div>\n *        <div hidden={hasResults}>\n *          <div>No results has been found for {searchState.query}</div>\n *        </div>\n *      </div>\n *    );\n * });\n *\n * const App = () => (\n *   <InstantSearch\n *      searchClient={searchClient}\n *      indexName=\"instant_search\"\n *    >\n *      <SearchBox />\n *      <Content />\n *    </InstantSearch>\n * );\n */\n\nexport default createConnector({\n  displayName: 'AlgoliaStateResults',\n  getProvidedProps: function getProvidedProps(props, searchState, searchResults) {\n    var results = getResults(searchResults, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n    return {\n      searchState: searchState,\n      searchResults: results,\n      allSearchResults: searchResults.results,\n      searching: searchResults.searching,\n      isSearchStalled: searchResults.isSearchStalled,\n      error: searchResults.error,\n      searchingForFacetValues: searchResults.searchingForFacetValues,\n      props: props\n    };\n  }\n});","import createConnector from '../core/createConnector';\nimport { HIGHLIGHT_TAGS, parseAlgoliaHit } from '../core/highlight';\n\nvar highlight = function highlight(_ref) {\n  var attribute = _ref.attribute,\n      hit = _ref.hit,\n      highlightProperty = _ref.highlightProperty,\n      _ref$preTag = _ref.preTag,\n      preTag = _ref$preTag === void 0 ? HIGHLIGHT_TAGS.highlightPreTag : _ref$preTag,\n      _ref$postTag = _ref.postTag,\n      postTag = _ref$postTag === void 0 ? HIGHLIGHT_TAGS.highlightPostTag : _ref$postTag;\n  return parseAlgoliaHit({\n    attribute: attribute,\n    highlightProperty: highlightProperty,\n    hit: hit,\n    preTag: preTag,\n    postTag: postTag\n  });\n};\n/**\n * connectHighlight connector provides the logic to create an highlighter\n * component that will retrieve, parse and render an highlighted attribute\n * from an Algolia hit.\n * @name connectHighlight\n * @kind connector\n * @category connector\n * @providedPropType {function} highlight - function to retrieve and parse an attribute from a hit. It takes a configuration object with 3 attributes: `highlightProperty` which is the property that contains the highlight structure from the records, `attribute` which is the name of the attribute (it can be either a string or an array of strings) to look for and `hit` which is the hit from Algolia. It returns an array of objects `{value: string, isHighlighted: boolean}`. If the element that corresponds to the attribute is an array of strings, it will return a nested array of objects.\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, SearchBox, Hits, connectHighlight } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const CustomHighlight = connectHighlight(\n *   ({ highlight, attribute, hit, highlightProperty }) => {\n *     const highlights = highlight({\n *       highlightProperty: '_highlightResult',\n *       attribute,\n *       hit\n *     });\n *\n *     return highlights.map(part => part.isHighlighted ? (\n *       <mark>{part.value}</mark>\n *     ) : (\n *       <span>{part.value}</span>\n *     ));\n *   }\n * );\n *\n * const Hit = ({ hit }) => (\n *   <p>\n *     <CustomHighlight attribute=\"name\" hit={hit} />\n *   </p>\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <SearchBox defaultRefinement=\"pho\" />\n *     <Hits hitComponent={Hit} />\n *   </InstantSearch>\n * );\n */\n\n\nexport default createConnector({\n  displayName: 'AlgoliaHighlighter',\n  propTypes: {},\n  getProvidedProps: function getProvidedProps() {\n    return {\n      highlight: highlight\n    };\n  }\n});","import createConnector from '../core/createConnector';\n/**\n * connectPoweredBy connector provides the logic to build a widget that\n * will display a link to algolia.\n * @name connectPoweredBy\n * @kind connector\n * @providedPropType {string} url - the url to redirect to algolia\n */\n\nexport default createConnector({\n  displayName: 'AlgoliaPoweredBy',\n  getProvidedProps: function getProvidedProps() {\n    var hostname = typeof window === 'undefined' ? '' : window.location.hostname;\n    var url = 'https://www.algolia.com/?' + 'utm_source=react-instantsearch&' + 'utm_medium=website&' + \"utm_content=\".concat(hostname, \"&\") + 'utm_campaign=poweredby';\n    return {\n      url: url\n    };\n  }\n});","import createConnector from '../core/createConnector';\nimport { getResults } from '../core/indexUtils';\nimport { addAbsolutePositions, addQueryID } from '../core/utils';\n/**\n * connectHits connector provides the logic to create connected\n * components that will render the results retrieved from\n * Algolia.\n *\n * To configure the number of hits retrieved, use [HitsPerPage widget](widgets/HitsPerPage.html),\n * [connectHitsPerPage connector](connectors/connectHitsPerPage.html) or pass the hitsPerPage\n * prop to a [Configure](guide/Search_parameters.html) widget.\n *\n * **Warning:** you will need to use the **objectID** property available on every hit as a key\n * when iterating over them. This will ensure you have the best possible UI experience\n * especially on slow networks.\n * @name connectHits\n * @kind connector\n * @providedPropType {array.<object>} hits - the records that matched the search state\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, Highlight, connectHits } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n * const CustomHits = connectHits(({ hits }) => (\n *   <div>\n *     {hits.map(hit =>\n *       <p key={hit.objectID}>\n *         <Highlight attribute=\"name\" hit={hit} />\n *       </p>\n *     )}\n *   </div>\n * ));\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <CustomHits />\n *   </InstantSearch>\n * );\n */\n\nexport default createConnector({\n  displayName: 'AlgoliaHits',\n  getProvidedProps: function getProvidedProps(props, searchState, searchResults) {\n    var results = getResults(searchResults, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n\n    if (!results) {\n      return {\n        hits: []\n      };\n    }\n\n    var hitsWithPositions = addAbsolutePositions(results.hits, results.hitsPerPage, results.page);\n    var hitsWithPositionsAndQueryID = addQueryID(hitsWithPositions, results.queryID);\n    return {\n      hits: hitsWithPositionsAndQueryID\n    };\n  },\n\n  /**\n   * Hits needs to be considered as a widget to trigger a search,\n   * even if no other widgets are used.\n   *\n   * To be considered as a widget you need either:\n   * - getSearchParameters\n   * - getMetadata\n   * - transitionState\n   *\n   * See: createConnector.tsx\n   */\n  getSearchParameters: function getSearchParameters(searchParameters) {\n    return searchParameters;\n  }\n});","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport React, { Component, Children } from 'react';\nimport PropTypes from 'prop-types';\nimport { InstantSearchConsumer, IndexProvider } from '../core/context';\n\nfunction getIndexContext(props) {\n  return {\n    targetedIndex: props.indexId\n  };\n}\n/**\n * The component that allows you to apply widgets to a dedicated index. It's\n * useful if you want to build an interface that targets multiple indices.\n *\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, Index, SearchBox, Hits, Configure } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <Configure hitsPerPage={5} />\n *     <SearchBox />\n *     <Index indexName=\"instant_search\">\n *       <Hits />\n *     </Index>\n *     <Index indexName=\"bestbuy\">\n *       <Hits />\n *     </Index>\n *   </InstantSearch>\n * );\n */\n\n\nvar Index = /*#__PURE__*/function (_Component) {\n  _inherits(Index, _Component);\n\n  _createClass(Index, null, [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(props) {\n      return {\n        indexContext: getIndexContext(props)\n      };\n    }\n  }]);\n\n  function Index(props) {\n    var _this;\n\n    _classCallCheck(this, Index);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Index).call(this, props));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      indexContext: getIndexContext(_this.props)\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"unregisterWidget\", void 0);\n\n    _this.props.contextValue.onSearchParameters(_this.getSearchParameters.bind(_assertThisInitialized(_this)), {\n      ais: _this.props.contextValue,\n      multiIndexContext: _this.state.indexContext\n    }, _this.props, undefined);\n\n    return _this;\n  }\n\n  _createClass(Index, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this.unregisterWidget = this.props.contextValue.widgetsManager.registerWidget(this);\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps) {\n      if (this.props.indexName !== prevProps.indexName) {\n        this.props.contextValue.widgetsManager.update();\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (typeof this.unregisterWidget === 'function') {\n        this.unregisterWidget();\n      }\n    }\n  }, {\n    key: \"getSearchParameters\",\n    value: function getSearchParameters(searchParameters, props) {\n      return searchParameters.setIndex(this.props ? this.props.indexName : props.indexName);\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var childrenCount = Children.count(this.props.children);\n\n      if (childrenCount === 0) {\n        return null;\n      }\n\n      return React.createElement(IndexProvider, {\n        value: this.state.indexContext\n      }, this.props.children);\n    }\n  }]);\n\n  return Index;\n}(Component);\n\n_defineProperty(Index, \"propTypes\", {\n  indexName: PropTypes.string.isRequired,\n  indexId: PropTypes.string.isRequired,\n  children: PropTypes.node\n});\n\nvar IndexWrapper = function IndexWrapper(props) {\n  var inferredIndexId = props.indexName;\n  return React.createElement(InstantSearchConsumer, null, function (contextValue) {\n    return React.createElement(Index, _extends({\n      contextValue: contextValue,\n      indexId: inferredIndexId\n    }, props));\n  });\n};\n\nexport var IndexComponentWithoutContext = Index;\nexport default IndexWrapper;","import React from \"react\";\r\n\r\nconst AlgoliaLogo = ({ className }) => (\r\n  <svg\r\n    xmlns=\"http://www.w3.org/2000/svg\"\r\n    baseProfile=\"basic\"\r\n    viewBox=\"0 0 1366 362\"\r\n    width=\"100\"\r\n    height=\"27\"\r\n    className={className}\r\n  >\r\n    <linearGradient\r\n      id=\"g\"\r\n      x1=\"428.258\"\r\n      x2=\"434.145\"\r\n      y1=\"404.15\"\r\n      y2=\"409.85\"\r\n      gradientUnits=\"userSpaceOnUse\"\r\n      gradientTransform=\"matrix(94.045 0 0 -94.072 -40381.527 38479.52)\"\r\n    >\r\n      <stop offset=\"0\" stopColor=\"#00AEFF\"></stop>\r\n      <stop offset=\"1\" stopColor=\"#3369E7\"></stop>\r\n    </linearGradient>\r\n    <path\r\n      d=\"M61.8 15.4h242.8c23.9 0 43.4 19.4 43.4 43.4v242.9c0 23.9-19.4 43.4-43.4 43.4H61.8c-23.9 0-43.4-19.4-43.4-43.4v-243c0-23.9 19.4-43.3 43.4-43.3z\"\r\n      fill=\"url(#g)\"\r\n    ></path>\r\n    <path\r\n      d=\"M187 98.7c-51.4 0-93.1 41.7-93.1 93.2S135.6 285 187 285s93.1-41.7 93.1-93.2-41.6-93.1-93.1-93.1zm0 158.8c-36.2 0-65.6-29.4-65.6-65.6s29.4-65.6 65.6-65.6 65.6 29.4 65.6 65.6-29.3 65.6-65.6 65.6zm0-117.8v48.9c0 1.4 1.5 2.4 2.8 1.7l43.4-22.5c1-.5 1.3-1.7.8-2.7-9-15.8-25.7-26.6-45-27.3-1 0-2 .8-2 1.9zm-60.8-35.9l-5.7-5.7c-5.6-5.6-14.6-5.6-20.2 0l-6.8 6.8c-5.6 5.6-5.6 14.6 0 20.2l5.6 5.6c.9.9 2.2.7 3-.2 3.3-4.5 6.9-8.8 10.9-12.8 4.1-4.1 8.3-7.7 12.9-11 1-.6 1.1-2 .3-2.9zM217.5 89V77.7c0-7.9-6.4-14.3-14.3-14.3h-33.3c-7.9 0-14.3 6.4-14.3 14.3v11.6c0 1.3 1.2 2.2 2.5 1.9 9.3-2.7 19.1-4.1 29-4.1 9.5 0 18.9 1.3 28 3.8 1.2.3 2.4-.6 2.4-1.9z\"\r\n      fill=\"#FFFFFF\"\r\n    ></path>\r\n    <path\r\n      d=\"M842.5 267.6c0 26.7-6.8 46.2-20.5 58.6-13.7 12.4-34.6 18.6-62.8 18.6-10.3 0-31.7-2-48.8-5.8l6.3-31c14.3 3 33.2 3.8 43.1 3.8 15.7 0 26.9-3.2 33.6-9.6s10-15.9 10-28.5v-6.4c-3.9 1.9-9 3.8-15.3 5.8-6.3 1.9-13.6 2.9-21.8 2.9-10.8 0-20.6-1.7-29.5-5.1-8.9-3.4-16.6-8.4-22.9-15-6.3-6.6-11.3-14.9-14.8-24.8s-5.3-27.6-5.3-40.6c0-12.2 1.9-27.5 5.6-37.7 3.8-10.2 9.2-19 16.5-26.3 7.2-7.3 16-12.9 26.3-17s22.4-6.7 35.5-6.7c12.7 0 24.4 1.6 35.8 3.5 11.4 1.9 21.1 3.9 29 6.1v155.2zm-108.7-77.2c0 16.4 3.6 34.6 10.8 42.2 7.2 7.6 16.5 11.4 27.9 11.4 6.2 0 12.1-.9 17.6-2.6 5.5-1.7 9.9-3.7 13.4-6.1v-97.1c-2.8-.6-14.5-3-25.8-3.3-14.2-.4-25 5.4-32.6 14.7-7.5 9.3-11.3 25.6-11.3 40.8zm294.3 0c0 13.2-1.9 23.2-5.8 34.1s-9.4 20.2-16.5 27.9c-7.1 7.7-15.6 13.7-25.6 17.9s-25.4 6.6-33.1 6.6c-7.7-.1-23-2.3-32.9-6.6-9.9-4.3-18.4-10.2-25.5-17.9-7.1-7.7-12.6-17-16.6-27.9s-6-20.9-6-34.1c0-13.2 1.8-25.9 5.8-36.7 4-10.8 9.6-20 16.8-27.7s15.8-13.6 25.6-17.8c9.9-4.2 20.8-6.2 32.6-6.2s22.7 2.1 32.7 6.2c10 4.2 18.6 10.1 25.6 17.8 7.1 7.7 12.6 16.9 16.6 27.7 4.2 10.8 6.3 23.5 6.3 36.7zm-40 .1c0-16.9-3.7-31-10.9-40.8-7.2-9.9-17.3-14.8-30.2-14.8-12.9 0-23 4.9-30.2 14.8-7.2 9.9-10.7 23.9-10.7 40.8 0 17.1 3.6 28.6 10.8 38.5 7.2 10 17.3 14.9 30.2 14.9 12.9 0 23-5 30.2-14.9 7.2-10 10.8-21.4 10.8-38.5zm127.1 86.4c-64.1.3-64.1-51.8-64.1-60.1L1051 32l39.1-6.2v183.6c0 4.7 0 34.5 25.1 34.6v32.9zm68.9 0h-39.3V108.1l39.3-6.2v175zm-19.7-193.5c13.1 0 23.8-10.6 23.8-23.7S1177.6 36 1164.4 36s-23.8 10.6-23.8 23.7 10.7 23.7 23.8 23.7zm117.4 18.6c12.9 0 23.8 1.6 32.6 4.8 8.8 3.2 15.9 7.7 21.1 13.4s8.9 13.5 11.1 21.7c2.3 8.2 3.4 17.2 3.4 27.1v100.6c-6 1.3-15.1 2.8-27.3 4.6s-25.9 2.7-41.1 2.7c-10.1 0-19.4-1-27.7-2.9-8.4-1.9-15.5-5-21.5-9.3-5.9-4.3-10.5-9.8-13.9-16.6-3.3-6.8-5-16.4-5-26.4 0-9.6 1.9-15.7 5.6-22.3 3.8-6.6 8.9-12 15.3-16.2 6.5-4.2 13.9-7.2 22.4-9s17.4-2.7 26.6-2.7c4.3 0 8.8.3 13.6.8s9.8 1.4 15.2 2.7v-6.4c0-4.5-.5-8.8-1.6-12.8-1.1-4.1-3-7.6-5.6-10.7-2.7-3.1-6.2-5.5-10.6-7.2s-10-3-16.7-3c-9 0-17.2 1.1-24.7 2.4-7.5 1.3-13.7 2.8-18.4 4.5l-4.7-32.1c4.9-1.7 12.2-3.4 21.6-5.1s19.5-2.6 30.3-2.6zm3.3 141.9c12 0 20.9-.7 27.1-1.9v-39.8c-2.2-.6-5.3-1.3-9.4-1.9-4.1-.6-8.6-1-13.6-1-4.3 0-8.7.3-13.1 1-4.4.6-8.4 1.8-11.9 3.5s-6.4 4.1-8.5 7.2c-2.2 3.1-3.2 4.9-3.2 9.6 0 9.2 3.2 14.5 9 18 5.9 3.6 13.7 5.3 23.6 5.3zM512.9 103c12.9 0 23.8 1.6 32.6 4.8 8.8 3.2 15.9 7.7 21.1 13.4 5.3 5.8 8.9 13.5 11.1 21.7 2.3 8.2 3.4 17.2 3.4 27.1v100.6c-6 1.3-15.1 2.8-27.3 4.6-12.2 1.8-25.9 2.7-41.1 2.7-10.1 0-19.4-1-27.7-2.9-8.4-1.9-15.5-5-21.5-9.3-5.9-4.3-10.5-9.8-13.9-16.6-3.3-6.8-5-16.4-5-26.4 0-9.6 1.9-15.7 5.6-22.3 3.8-6.6 8.9-12 15.3-16.2 6.5-4.2 13.9-7.2 22.4-9s17.4-2.7 26.6-2.7c4.3 0 8.8.3 13.6.8 4.7.5 9.8 1.4 15.2 2.7v-6.4c0-4.5-.5-8.8-1.6-12.8-1.1-4.1-3-7.6-5.6-10.7-2.7-3.1-6.2-5.5-10.6-7.2-4.4-1.7-10-3-16.7-3-9 0-17.2 1.1-24.7 2.4-7.5 1.3-13.7 2.8-18.4 4.5l-4.7-32.1c4.9-1.7 12.2-3.4 21.6-5.1 9.4-1.8 19.5-2.6 30.3-2.6zm3.4 142c12 0 20.9-.7 27.1-1.9v-39.8c-2.2-.6-5.3-1.3-9.4-1.9-4.1-.6-8.6-1-13.6-1-4.3 0-8.7.3-13.1 1-4.4.6-8.4 1.8-11.9 3.5s-6.4 4.1-8.5 7.2c-2.2 3.1-3.2 4.9-3.2 9.6 0 9.2 3.2 14.5 9 18s13.7 5.3 23.6 5.3zm158.5 31.9c-64.1.3-64.1-51.8-64.1-60.1L610.6 32l39.1-6.2v183.6c0 4.7 0 34.5 25.1 34.6v32.9z\"\r\n      fill=\"#182359\"\r\n    ></path>\r\n  </svg>\r\n);\r\n\r\nexport default AlgoliaLogo;\r\n","import React from \"react\";\r\nimport { Link } from \"gatsby\";\r\nimport {\r\n  connectStateResults,\r\n  connectHighlight,\r\n  connectHits,\r\n  connectPoweredBy,\r\n  Index,\r\n  Snippet,\r\n} from \"react-instantsearch-dom\";\r\n\r\nimport AlgoliaLogo from \"./algolia-logo\";\r\n\r\nimport { useIntl } from \"../../contexts/IntlContext\";\r\n\r\nconst HitCount = connectStateResults(({ searchResults }) => {\r\n  const hitCount = searchResults && searchResults.nbHits;\r\n\r\n  return (\r\n    <div className=\"flex justify-center mb-3.5\">\r\n      {hitCount > 0\r\n        ? `${hitCount} result${hitCount !== 1 ? \"s\" : \"\"}`\r\n        : \"No results\"}\r\n    </div>\r\n  );\r\n});\r\n\r\nconst CustomHighlight = connectHighlight(({ highlight, attribute, hit }) => {\r\n  const parsedHit = highlight({\r\n    highlightProperty: \"_highlightResult\",\r\n    attribute,\r\n    hit,\r\n  });\r\n\r\n  return (\r\n    <span>\r\n      {parsedHit.map((part, index) =>\r\n        part.isHighlighted ? (\r\n          <mark key={index} className=\"bg-green-light\">\r\n            {part.value}\r\n          </mark>\r\n        ) : (\r\n          <span key={index}>{part.value}</span>\r\n        )\r\n      )}\r\n    </span>\r\n  );\r\n});\r\n\r\nconst CustomPoweredBy = connectPoweredBy(({ url }) => (\r\n  <div className=\"flex justify-end items-center mt-3.5 text-xs\">\r\n    <a\r\n      href={url}\r\n      target=\"_blank\"\r\n      aria-label=\"Algolia\"\r\n      rel=\"noopener noreferrer\"\r\n    >\r\n      <span>Search by</span>\r\n      <AlgoliaLogo className=\"w-20 ml-1.5\" />\r\n    </a>\r\n  </div>\r\n));\r\n\r\nconst CustomHits = connectHits(({ hits, lang }) => (\r\n  <ul className=\"max-h-60-screen overflow-y-auto\">\r\n    {hits.map(hit => (\r\n      <li key={hit.objectID}>\r\n        {hit[`paths_${lang}`].map(path => (\r\n          <div key={path} className=\"mb-2 p-1 hover:bg-gray-100\">\r\n            <Link to={path} className=\"block\">\r\n              <CustomHighlight attribute={`title_${lang}`} hit={hit} />\r\n            </Link>\r\n            {/* <Snippet attribute=\"htmlContent\" hit={hit} tagName=\"mark\" /> */}\r\n          </div>\r\n        ))}\r\n      </li>\r\n    ))}\r\n  </ul>\r\n));\r\n\r\nconst SearchResult = ({ indices, show }) => {\r\n  const { lang } = useIntl();\r\n\r\n  return (\r\n    <div\r\n      className={`mt-2 p-4 absolute right-0 top-full z-10 bg-white shadow-lg max-w-lg w-80-screen ${\r\n        show ? \"block\" : \"hidden\"\r\n      }`}\r\n    >\r\n      {indices.map(index => (\r\n        <Index indexName={index.name} key={index.name}>\r\n          <HitCount />\r\n          <CustomHits lang={lang} />\r\n        </Index>\r\n      ))}\r\n      <CustomPoweredBy />\r\n    </div>\r\n  );\r\n};\r\n\r\nexport default SearchResult;\r\n","import { useEffect } from \"react\";\r\n\r\nconst events = [`mousedown`, `touchstart`];\r\n\r\nexport default (ref, onClickOutside) => {\r\n  const isOutside = element => !ref.current || !ref.current.contains(element);\r\n\r\n  const onClick = event => {\r\n    if (isOutside(event.target)) {\r\n      onClickOutside();\r\n    }\r\n  };\r\n\r\n  useEffect(() => {\r\n    for (const event of events) {\r\n      document.addEventListener(event, onClick);\r\n    }\r\n    return () => {\r\n      for (const event of events) document.removeEventListener(event, onClick);\r\n    };\r\n  });\r\n};\r\n","import React, { createRef, useState } from \"react\";\r\nimport algoliasearch from \"algoliasearch/lite\";\r\nimport { Configure, InstantSearch } from \"react-instantsearch-dom\";\r\n\r\nimport { useIntl } from \"../../contexts/IntlContext\";\r\n\r\nimport SearchBox from \"./search-box\";\r\nimport SearchResult from \"./search-result\";\r\nimport useClickOutside from \"./use-click-outside\";\r\n\r\nconst Search = ({ indices }) => {\r\n  const { lang } = useIntl();\r\n  const rootRef = createRef();\r\n  const [query, setQuery] = useState();\r\n  const [hasFocus, setFocus] = useState(false);\r\n  const searchClient = algoliasearch(\r\n    process.env.GATSBY_ALGOLIA_APP_ID,\r\n    process.env.GATSBY_ALGOLIA_SEARCH_KEY\r\n  );\r\n  useClickOutside(rootRef, () => setFocus(false));\r\n\r\n  return (\r\n    <>\r\n      {lang ? (\r\n        <div className=\"relative my-2.5 mr-6 ml-0\" ref={rootRef}>\r\n          <InstantSearch\r\n            searchClient={searchClient}\r\n            indexName={indices[0].name}\r\n            onSearchStateChange={({ query }) => setQuery(query)}\r\n          >\r\n            <Configure restrictSearchableAttributes={[`title_${lang}`]} />\r\n            <SearchBox onFocus={() => setFocus(true)} hasFocus={hasFocus} />\r\n            <SearchResult\r\n              show={query && query.length > 0 && hasFocus}\r\n              indices={indices}\r\n            />\r\n          </InstantSearch>\r\n        </div>\r\n      ) : null}\r\n    </>\r\n  );\r\n};\r\n\r\nexport default Search;\r\n","import React from \"react\";\r\nimport PropTypes from \"prop-types\";\r\nimport { Link, useStaticQuery, graphql } from \"gatsby\";\r\n\r\nimport { useIntl } from \"../contexts/IntlContext\";\r\n\r\nimport LandsLogo from \"./lands-logo\";\r\nimport Language from \"./language\";\r\nimport Search from \"./search\";\r\n\r\nconst searchIndices = [{ name: `Docs`, title: `Docs` }];\r\n\r\nconst Header = ({ siteTitle }) => {\r\n  const { lang } = useIntl();\r\n\r\n  const {\r\n    site: {\r\n      siteMetadata: { defaultLang },\r\n    },\r\n  } = useStaticQuery(graphql`\r\n    query HeaderDefaultLangQuery {\r\n      site {\r\n        siteMetadata {\r\n          defaultLang\r\n        }\r\n      }\r\n    }\r\n  `);\r\n\r\n  return (\r\n    <header className=\"sticky top-0 z-50 bg-gray-100\">\r\n      <div className=\"flex mx-auto h-20 max-w-screen-xl py-3 px-4\">\r\n        <div className=\"flex items-center w-64\">\r\n          <Link\r\n            to={\"/\" + (lang && defaultLang !== lang ? lang : \"\")}\r\n            className=\"overflow-hidden w-9 sm:w-auto\"\r\n            aria-label=\"Link to home page\"\r\n          >\r\n            <span className=\"sr-only\">{siteTitle}</span>\r\n            <LandsLogo rootCssClasses=\"w-auto h-10\" />\r\n          </Link>\r\n        </div>\r\n        <div className=\"flex-auto flex justify-end items-center\">\r\n          <Search indices={searchIndices} />\r\n          <Language />\r\n        </div>\r\n      </div>\r\n    </header>\r\n  );\r\n};\r\n\r\nHeader.propTypes = {\r\n  siteTitle: PropTypes.string,\r\n};\r\n\r\nHeader.defaultProps = {\r\n  siteTitle: ``,\r\n};\r\n\r\nexport default Header;\r\n","import React from \"react\";\r\nimport PropTypes from \"prop-types\";\r\nimport { useStaticQuery, graphql } from \"gatsby\";\r\n\r\nimport \"../styles/content-area.css\";\r\n\r\nimport Header from \"./header\";\r\n\r\nconst Layout = ({ children }) => {\r\n  const data = useStaticQuery(graphql`\r\n    query SiteTitleQuery {\r\n      site {\r\n        siteMetadata {\r\n          title\r\n        }\r\n      }\r\n    }\r\n  `);\r\n\r\n  return (\r\n    <>\r\n      <Header siteTitle={data.site.siteMetadata?.title || `Title`} />\r\n      <main className=\"flex mx-auto max-w-screen-xl px-4\">{children}</main>\r\n    </>\r\n  );\r\n};\r\n\r\nLayout.propTypes = {\r\n  children: PropTypes.node.isRequired,\r\n};\r\n\r\nexport default Layout;\r\n","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar find = require('./find');\n/**\n * Transform sort format from user friendly notation to lodash format\n * @param {string[]} sortBy array of predicate of the form \"attribute:order\"\n * @param {string[]} [defaults] array of predicate of the form \"attribute:order\"\n * @return {array.<string[]>} array containing 2 elements : attributes, orders\n */\n\n\nmodule.exports = function formatSort(sortBy, defaults) {\n  var defaultInstructions = (defaults || []).map(function (sort) {\n    return sort.split(':');\n  });\n  return sortBy.reduce(function preparePredicate(out, sort) {\n    var sortInstruction = sort.split(':');\n    var matchingDefault = find(defaultInstructions, function (defaultInstruction) {\n      return defaultInstruction[0] === sortInstruction[0];\n    });\n\n    if (sortInstruction.length > 1 || !matchingDefault) {\n      out[0].push(sortInstruction[0]);\n      out[1].push(sortInstruction[1]);\n      return out;\n    }\n\n    out[0].push(matchingDefault[0]);\n    out[1].push(matchingDefault[1]);\n    return out;\n  }, [[], []]);\n};","/*! algoliasearch-lite.umd.js | 4.8.4 | © Algolia, inc. | https://github.com/algolia/algoliasearch-client-javascript */\n!function (e, t) {\n  \"object\" == typeof exports && \"undefined\" != typeof module ? module.exports = t() : \"function\" == typeof define && define.amd ? define(t) : (e = e || self).algoliasearch = t();\n}(this, function () {\n  \"use strict\";\n\n  function e(e, t, r) {\n    return t in e ? Object.defineProperty(e, t, {\n      value: r,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }) : e[t] = r, e;\n  }\n\n  function t(e, t) {\n    var r = Object.keys(e);\n\n    if (Object.getOwnPropertySymbols) {\n      var n = Object.getOwnPropertySymbols(e);\n      t && (n = n.filter(function (t) {\n        return Object.getOwnPropertyDescriptor(e, t).enumerable;\n      })), r.push.apply(r, n);\n    }\n\n    return r;\n  }\n\n  function r(r) {\n    for (var n = 1; n < arguments.length; n++) {\n      var o = null != arguments[n] ? arguments[n] : {};\n      n % 2 ? t(Object(o), !0).forEach(function (t) {\n        e(r, t, o[t]);\n      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(o)) : t(Object(o)).forEach(function (e) {\n        Object.defineProperty(r, e, Object.getOwnPropertyDescriptor(o, e));\n      });\n    }\n\n    return r;\n  }\n\n  function n(e, t) {\n    if (null == e) return {};\n\n    var r,\n        n,\n        o = function (e, t) {\n      if (null == e) return {};\n      var r,\n          n,\n          o = {},\n          a = Object.keys(e);\n\n      for (n = 0; n < a.length; n++) {\n        r = a[n], t.indexOf(r) >= 0 || (o[r] = e[r]);\n      }\n\n      return o;\n    }(e, t);\n\n    if (Object.getOwnPropertySymbols) {\n      var a = Object.getOwnPropertySymbols(e);\n\n      for (n = 0; n < a.length; n++) {\n        r = a[n], t.indexOf(r) >= 0 || Object.prototype.propertyIsEnumerable.call(e, r) && (o[r] = e[r]);\n      }\n    }\n\n    return o;\n  }\n\n  function o(e, t) {\n    return function (e) {\n      if (Array.isArray(e)) return e;\n    }(e) || function (e, t) {\n      if (!(Symbol.iterator in Object(e) || \"[object Arguments]\" === Object.prototype.toString.call(e))) return;\n      var r = [],\n          n = !0,\n          o = !1,\n          a = void 0;\n\n      try {\n        for (var u, i = e[Symbol.iterator](); !(n = (u = i.next()).done) && (r.push(u.value), !t || r.length !== t); n = !0) {\n          ;\n        }\n      } catch (e) {\n        o = !0, a = e;\n      } finally {\n        try {\n          n || null == i.return || i.return();\n        } finally {\n          if (o) throw a;\n        }\n      }\n\n      return r;\n    }(e, t) || function () {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }();\n  }\n\n  function a(e) {\n    return function (e) {\n      if (Array.isArray(e)) {\n        for (var t = 0, r = new Array(e.length); t < e.length; t++) {\n          r[t] = e[t];\n        }\n\n        return r;\n      }\n    }(e) || function (e) {\n      if (Symbol.iterator in Object(e) || \"[object Arguments]\" === Object.prototype.toString.call(e)) return Array.from(e);\n    }(e) || function () {\n      throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n    }();\n  }\n\n  function u(e) {\n    var t,\n        r = \"algoliasearch-client-js-\".concat(e.key),\n        n = function n() {\n      return void 0 === t && (t = e.localStorage || window.localStorage), t;\n    },\n        a = function a() {\n      return JSON.parse(n().getItem(r) || \"{}\");\n    };\n\n    return {\n      get: function get(e, t) {\n        var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {\n          miss: function miss() {\n            return Promise.resolve();\n          }\n        };\n        return Promise.resolve().then(function () {\n          var r = JSON.stringify(e),\n              n = a()[r];\n          return Promise.all([n || t(), void 0 !== n]);\n        }).then(function (e) {\n          var t = o(e, 2),\n              n = t[0],\n              a = t[1];\n          return Promise.all([n, a || r.miss(n)]);\n        }).then(function (e) {\n          return o(e, 1)[0];\n        });\n      },\n      set: function set(e, t) {\n        return Promise.resolve().then(function () {\n          var o = a();\n          return o[JSON.stringify(e)] = t, n().setItem(r, JSON.stringify(o)), t;\n        });\n      },\n      delete: function _delete(e) {\n        return Promise.resolve().then(function () {\n          var t = a();\n          delete t[JSON.stringify(e)], n().setItem(r, JSON.stringify(t));\n        });\n      },\n      clear: function clear() {\n        return Promise.resolve().then(function () {\n          n().removeItem(r);\n        });\n      }\n    };\n  }\n\n  function i(e) {\n    var t = a(e.caches),\n        r = t.shift();\n    return void 0 === r ? {\n      get: function get(e, t) {\n        var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {\n          miss: function miss() {\n            return Promise.resolve();\n          }\n        },\n            n = t();\n        return n.then(function (e) {\n          return Promise.all([e, r.miss(e)]);\n        }).then(function (e) {\n          return o(e, 1)[0];\n        });\n      },\n      set: function set(e, t) {\n        return Promise.resolve(t);\n      },\n      delete: function _delete(e) {\n        return Promise.resolve();\n      },\n      clear: function clear() {\n        return Promise.resolve();\n      }\n    } : {\n      get: function get(e, n) {\n        var o = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {\n          miss: function miss() {\n            return Promise.resolve();\n          }\n        };\n        return r.get(e, n, o).catch(function () {\n          return i({\n            caches: t\n          }).get(e, n, o);\n        });\n      },\n      set: function set(e, n) {\n        return r.set(e, n).catch(function () {\n          return i({\n            caches: t\n          }).set(e, n);\n        });\n      },\n      delete: function _delete(e) {\n        return r.delete(e).catch(function () {\n          return i({\n            caches: t\n          }).delete(e);\n        });\n      },\n      clear: function clear() {\n        return r.clear().catch(function () {\n          return i({\n            caches: t\n          }).clear();\n        });\n      }\n    };\n  }\n\n  function s() {\n    var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {\n      serializable: !0\n    },\n        t = {};\n    return {\n      get: function get(r, n) {\n        var o = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {\n          miss: function miss() {\n            return Promise.resolve();\n          }\n        },\n            a = JSON.stringify(r);\n        if (a in t) return Promise.resolve(e.serializable ? JSON.parse(t[a]) : t[a]);\n\n        var u = n(),\n            i = o && o.miss || function () {\n          return Promise.resolve();\n        };\n\n        return u.then(function (e) {\n          return i(e);\n        }).then(function () {\n          return u;\n        });\n      },\n      set: function set(r, n) {\n        return t[JSON.stringify(r)] = e.serializable ? JSON.stringify(n) : n, Promise.resolve(n);\n      },\n      delete: function _delete(e) {\n        return delete t[JSON.stringify(e)], Promise.resolve();\n      },\n      clear: function clear() {\n        return t = {}, Promise.resolve();\n      }\n    };\n  }\n\n  function c(e) {\n    for (var t = e.length - 1; t > 0; t--) {\n      var r = Math.floor(Math.random() * (t + 1)),\n          n = e[t];\n      e[t] = e[r], e[r] = n;\n    }\n\n    return e;\n  }\n\n  function l(e, t) {\n    return t ? (Object.keys(t).forEach(function (r) {\n      e[r] = t[r](e);\n    }), e) : e;\n  }\n\n  function f(e) {\n    for (var t = arguments.length, r = new Array(t > 1 ? t - 1 : 0), n = 1; n < t; n++) {\n      r[n - 1] = arguments[n];\n    }\n\n    var o = 0;\n    return e.replace(/%s/g, function () {\n      return encodeURIComponent(r[o++]);\n    });\n  }\n\n  var h = {\n    WithinQueryParameters: 0,\n    WithinHeaders: 1\n  };\n\n  function d(e, t) {\n    var r = e || {},\n        n = r.data || {};\n    return Object.keys(r).forEach(function (e) {\n      -1 === [\"timeout\", \"headers\", \"queryParameters\", \"data\", \"cacheable\"].indexOf(e) && (n[e] = r[e]);\n    }), {\n      data: Object.entries(n).length > 0 ? n : void 0,\n      timeout: r.timeout || t,\n      headers: r.headers || {},\n      queryParameters: r.queryParameters || {},\n      cacheable: r.cacheable\n    };\n  }\n\n  var m = {\n    Read: 1,\n    Write: 2,\n    Any: 3\n  },\n      p = 1,\n      v = 2,\n      y = 3;\n\n  function g(e) {\n    var t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : p;\n    return r(r({}, e), {}, {\n      status: t,\n      lastUpdate: Date.now()\n    });\n  }\n\n  function b(e) {\n    return \"string\" == typeof e ? {\n      protocol: \"https\",\n      url: e,\n      accept: m.Any\n    } : {\n      protocol: e.protocol || \"https\",\n      url: e.url,\n      accept: e.accept || m.Any\n    };\n  }\n\n  var O = \"GET\",\n      P = \"POST\";\n\n  function q(e, t) {\n    return Promise.all(t.map(function (t) {\n      return e.get(t, function () {\n        return Promise.resolve(g(t));\n      });\n    })).then(function (e) {\n      var r = e.filter(function (e) {\n        return function (e) {\n          return e.status === p || Date.now() - e.lastUpdate > 12e4;\n        }(e);\n      }),\n          n = e.filter(function (e) {\n        return function (e) {\n          return e.status === y && Date.now() - e.lastUpdate <= 12e4;\n        }(e);\n      }),\n          o = [].concat(a(r), a(n));\n      return {\n        getTimeout: function getTimeout(e, t) {\n          return (0 === n.length && 0 === e ? 1 : n.length + 3 + e) * t;\n        },\n        statelessHosts: o.length > 0 ? o.map(function (e) {\n          return b(e);\n        }) : t\n      };\n    });\n  }\n\n  function j(e, t, n, o) {\n    var u = [],\n        i = function (e, t) {\n      if (e.method === O || void 0 === e.data && void 0 === t.data) return;\n      var n = Array.isArray(e.data) ? e.data : r(r({}, e.data), t.data);\n      return JSON.stringify(n);\n    }(n, o),\n        s = function (e, t) {\n      var n = r(r({}, e.headers), t.headers),\n          o = {};\n      return Object.keys(n).forEach(function (e) {\n        var t = n[e];\n        o[e.toLowerCase()] = t;\n      }), o;\n    }(e, o),\n        c = n.method,\n        l = n.method !== O ? {} : r(r({}, n.data), o.data),\n        f = r(r(r({\n      \"x-algolia-agent\": e.userAgent.value\n    }, e.queryParameters), l), o.queryParameters),\n        h = 0,\n        d = function t(r, a) {\n      var l = r.pop();\n      if (void 0 === l) throw {\n        name: \"RetryError\",\n        message: \"Unreachable hosts - your application id may be incorrect. If the error persists, contact support@algolia.com.\",\n        transporterStackTrace: A(u)\n      };\n\n      var d = {\n        data: i,\n        headers: s,\n        method: c,\n        url: S(l, n.path, f),\n        connectTimeout: a(h, e.timeouts.connect),\n        responseTimeout: a(h, o.timeout)\n      },\n          m = function m(e) {\n        var t = {\n          request: d,\n          response: e,\n          host: l,\n          triesLeft: r.length\n        };\n        return u.push(t), t;\n      },\n          p = {\n        onSucess: function onSucess(e) {\n          return function (e) {\n            try {\n              return JSON.parse(e.content);\n            } catch (t) {\n              throw function (e, t) {\n                return {\n                  name: \"DeserializationError\",\n                  message: e,\n                  response: t\n                };\n              }(t.message, e);\n            }\n          }(e);\n        },\n        onRetry: function onRetry(n) {\n          var o = m(n);\n          return n.isTimedOut && h++, Promise.all([e.logger.info(\"Retryable failure\", x(o)), e.hostsCache.set(l, g(l, n.isTimedOut ? y : v))]).then(function () {\n            return t(r, a);\n          });\n        },\n        onFail: function onFail(e) {\n          throw m(e), function (e, t) {\n            var r = e.content,\n                n = e.status,\n                o = r;\n\n            try {\n              o = JSON.parse(r).message;\n            } catch (e) {}\n\n            return function (e, t, r) {\n              return {\n                name: \"ApiError\",\n                message: e,\n                status: t,\n                transporterStackTrace: r\n              };\n            }(o, n, t);\n          }(e, A(u));\n        }\n      };\n\n      return e.requester.send(d).then(function (e) {\n        return function (e, t) {\n          return function (e) {\n            var t = e.status;\n            return e.isTimedOut || function (e) {\n              var t = e.isTimedOut,\n                  r = e.status;\n              return !t && 0 == ~~r;\n            }(e) || 2 != ~~(t / 100) && 4 != ~~(t / 100);\n          }(e) ? t.onRetry(e) : 2 == ~~(e.status / 100) ? t.onSucess(e) : t.onFail(e);\n        }(e, p);\n      });\n    };\n\n    return q(e.hostsCache, t).then(function (e) {\n      return d(a(e.statelessHosts).reverse(), e.getTimeout);\n    });\n  }\n\n  function w(e) {\n    var t = {\n      value: \"Algolia for JavaScript (\".concat(e, \")\"),\n      add: function add(e) {\n        var r = \"; \".concat(e.segment).concat(void 0 !== e.version ? \" (\".concat(e.version, \")\") : \"\");\n        return -1 === t.value.indexOf(r) && (t.value = \"\".concat(t.value).concat(r)), t;\n      }\n    };\n    return t;\n  }\n\n  function S(e, t, r) {\n    var n = T(r),\n        o = \"\".concat(e.protocol, \"://\").concat(e.url, \"/\").concat(\"/\" === t.charAt(0) ? t.substr(1) : t);\n    return n.length && (o += \"?\".concat(n)), o;\n  }\n\n  function T(e) {\n    return Object.keys(e).map(function (t) {\n      return f(\"%s=%s\", t, (r = e[t], \"[object Object]\" === Object.prototype.toString.call(r) || \"[object Array]\" === Object.prototype.toString.call(r) ? JSON.stringify(e[t]) : e[t]));\n      var r;\n    }).join(\"&\");\n  }\n\n  function A(e) {\n    return e.map(function (e) {\n      return x(e);\n    });\n  }\n\n  function x(e) {\n    var t = e.request.headers[\"x-algolia-api-key\"] ? {\n      \"x-algolia-api-key\": \"*****\"\n    } : {};\n    return r(r({}, e), {}, {\n      request: r(r({}, e.request), {}, {\n        headers: r(r({}, e.request.headers), t)\n      })\n    });\n  }\n\n  var N = function N(e) {\n    var t = e.appId,\n        n = function (e, t, r) {\n      var n = {\n        \"x-algolia-api-key\": r,\n        \"x-algolia-application-id\": t\n      };\n      return {\n        headers: function headers() {\n          return e === h.WithinHeaders ? n : {};\n        },\n        queryParameters: function queryParameters() {\n          return e === h.WithinQueryParameters ? n : {};\n        }\n      };\n    }(void 0 !== e.authMode ? e.authMode : h.WithinHeaders, t, e.apiKey),\n        a = function (e) {\n      var t = e.hostsCache,\n          r = e.logger,\n          n = e.requester,\n          a = e.requestsCache,\n          u = e.responsesCache,\n          i = e.timeouts,\n          s = e.userAgent,\n          c = e.hosts,\n          l = e.queryParameters,\n          f = {\n        hostsCache: t,\n        logger: r,\n        requester: n,\n        requestsCache: a,\n        responsesCache: u,\n        timeouts: i,\n        userAgent: s,\n        headers: e.headers,\n        queryParameters: l,\n        hosts: c.map(function (e) {\n          return b(e);\n        }),\n        read: function read(e, t) {\n          var r = d(t, f.timeouts.read),\n              n = function n() {\n            return j(f, f.hosts.filter(function (e) {\n              return 0 != (e.accept & m.Read);\n            }), e, r);\n          };\n\n          if (!0 !== (void 0 !== r.cacheable ? r.cacheable : e.cacheable)) return n();\n          var a = {\n            request: e,\n            mappedRequestOptions: r,\n            transporter: {\n              queryParameters: f.queryParameters,\n              headers: f.headers\n            }\n          };\n          return f.responsesCache.get(a, function () {\n            return f.requestsCache.get(a, function () {\n              return f.requestsCache.set(a, n()).then(function (e) {\n                return Promise.all([f.requestsCache.delete(a), e]);\n              }, function (e) {\n                return Promise.all([f.requestsCache.delete(a), Promise.reject(e)]);\n              }).then(function (e) {\n                var t = o(e, 2);\n                t[0];\n                return t[1];\n              });\n            });\n          }, {\n            miss: function miss(e) {\n              return f.responsesCache.set(a, e);\n            }\n          });\n        },\n        write: function write(e, t) {\n          return j(f, f.hosts.filter(function (e) {\n            return 0 != (e.accept & m.Write);\n          }), e, d(t, f.timeouts.write));\n        }\n      };\n      return f;\n    }(r(r({\n      hosts: [{\n        url: \"\".concat(t, \"-dsn.algolia.net\"),\n        accept: m.Read\n      }, {\n        url: \"\".concat(t, \".algolia.net\"),\n        accept: m.Write\n      }].concat(c([{\n        url: \"\".concat(t, \"-1.algolianet.com\")\n      }, {\n        url: \"\".concat(t, \"-2.algolianet.com\")\n      }, {\n        url: \"\".concat(t, \"-3.algolianet.com\")\n      }]))\n    }, e), {}, {\n      headers: r(r(r({}, n.headers()), {\n        \"content-type\": \"application/x-www-form-urlencoded\"\n      }), e.headers),\n      queryParameters: r(r({}, n.queryParameters()), e.queryParameters)\n    }));\n\n    return l({\n      transporter: a,\n      appId: t,\n      addAlgoliaAgent: function addAlgoliaAgent(e, t) {\n        a.userAgent.add({\n          segment: e,\n          version: t\n        });\n      },\n      clearCache: function clearCache() {\n        return Promise.all([a.requestsCache.clear(), a.responsesCache.clear()]).then(function () {});\n      }\n    }, e.methods);\n  },\n      C = function C(e) {\n    return function (t) {\n      var r = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {},\n          n = {\n        transporter: e.transporter,\n        appId: e.appId,\n        indexName: t\n      };\n      return l(n, r.methods);\n    };\n  },\n      k = function k(e) {\n    return function (t, n) {\n      var o = t.map(function (e) {\n        return r(r({}, e), {}, {\n          params: T(e.params || {})\n        });\n      });\n      return e.transporter.read({\n        method: P,\n        path: \"1/indexes/*/queries\",\n        data: {\n          requests: o\n        },\n        cacheable: !0\n      }, n);\n    };\n  },\n      J = function J(e) {\n    return function (t, o) {\n      return Promise.all(t.map(function (t) {\n        var a = t.params,\n            u = a.facetName,\n            i = a.facetQuery,\n            s = n(a, [\"facetName\", \"facetQuery\"]);\n        return C(e)(t.indexName, {\n          methods: {\n            searchForFacetValues: F\n          }\n        }).searchForFacetValues(u, i, r(r({}, o), s));\n      }));\n    };\n  },\n      E = function E(e) {\n    return function (t, r, n) {\n      return e.transporter.read({\n        method: P,\n        path: f(\"1/answers/%s/prediction\", e.indexName),\n        data: {\n          query: t,\n          queryLanguages: r\n        },\n        cacheable: !0\n      }, n);\n    };\n  },\n      I = function I(e) {\n    return function (t, r) {\n      return e.transporter.read({\n        method: P,\n        path: f(\"1/indexes/%s/query\", e.indexName),\n        data: {\n          query: t\n        },\n        cacheable: !0\n      }, r);\n    };\n  },\n      F = function F(e) {\n    return function (t, r, n) {\n      return e.transporter.read({\n        method: P,\n        path: f(\"1/indexes/%s/facets/%s/query\", e.indexName, t),\n        data: {\n          facetQuery: r\n        },\n        cacheable: !0\n      }, n);\n    };\n  },\n      R = 1,\n      D = 2,\n      W = 3;\n\n  function H(e, t, n) {\n    var o,\n        a = {\n      appId: e,\n      apiKey: t,\n      timeouts: {\n        connect: 1,\n        read: 2,\n        write: 30\n      },\n      requester: {\n        send: function send(e) {\n          return new Promise(function (t) {\n            var r = new XMLHttpRequest();\n            r.open(e.method, e.url, !0), Object.keys(e.headers).forEach(function (t) {\n              return r.setRequestHeader(t, e.headers[t]);\n            });\n\n            var n,\n                o = function o(e, n) {\n              return setTimeout(function () {\n                r.abort(), t({\n                  status: 0,\n                  content: n,\n                  isTimedOut: !0\n                });\n              }, 1e3 * e);\n            },\n                a = o(e.connectTimeout, \"Connection timeout\");\n\n            r.onreadystatechange = function () {\n              r.readyState > r.OPENED && void 0 === n && (clearTimeout(a), n = o(e.responseTimeout, \"Socket timeout\"));\n            }, r.onerror = function () {\n              0 === r.status && (clearTimeout(a), clearTimeout(n), t({\n                content: r.responseText || \"Network request failed\",\n                status: r.status,\n                isTimedOut: !1\n              }));\n            }, r.onload = function () {\n              clearTimeout(a), clearTimeout(n), t({\n                content: r.responseText,\n                status: r.status,\n                isTimedOut: !1\n              });\n            }, r.send(e.data);\n          });\n        }\n      },\n      logger: (o = W, {\n        debug: function debug(e, t) {\n          return R >= o && console.debug(e, t), Promise.resolve();\n        },\n        info: function info(e, t) {\n          return D >= o && console.info(e, t), Promise.resolve();\n        },\n        error: function error(e, t) {\n          return console.error(e, t), Promise.resolve();\n        }\n      }),\n      responsesCache: s(),\n      requestsCache: s({\n        serializable: !1\n      }),\n      hostsCache: i({\n        caches: [u({\n          key: \"\".concat(\"4.8.4\", \"-\").concat(e)\n        }), s()]\n      }),\n      userAgent: w(\"4.8.4\").add({\n        segment: \"Browser\",\n        version: \"lite\"\n      }),\n      authMode: h.WithinQueryParameters\n    };\n    return N(r(r(r({}, a), n), {}, {\n      methods: {\n        search: k,\n        searchForFacetValues: J,\n        multipleQueries: k,\n        multipleSearchForFacetValues: J,\n        initIndex: function initIndex(e) {\n          return function (t) {\n            return C(e)(t, {\n              methods: {\n                search: I,\n                searchForFacetValues: F,\n                findAnswers: E\n              }\n            });\n          };\n        }\n      }\n    }));\n  }\n\n  return H.version = \"4.8.4\", H;\n});","'use strict';\n\nfunction clone(value) {\n  if (typeof value === 'object' && value !== null) {\n    return _merge(Array.isArray(value) ? [] : {}, value);\n  }\n\n  return value;\n}\n\nfunction isObjectOrArrayOrFunction(value) {\n  return typeof value === 'function' || Array.isArray(value) || Object.prototype.toString.call(value) === '[object Object]';\n}\n\nfunction _merge(target, source) {\n  if (target === source) {\n    return target;\n  }\n\n  for (var key in source) {\n    if (!Object.prototype.hasOwnProperty.call(source, key)) {\n      continue;\n    }\n\n    var sourceVal = source[key];\n    var targetVal = target[key];\n\n    if (typeof targetVal !== 'undefined' && typeof sourceVal === 'undefined') {\n      continue;\n    }\n\n    if (isObjectOrArrayOrFunction(targetVal) && isObjectOrArrayOrFunction(sourceVal)) {\n      target[key] = _merge(targetVal, sourceVal);\n    } else {\n      target[key] = clone(sourceVal);\n    }\n  }\n\n  return target;\n}\n/**\n * This method is like Object.assign, but recursively merges own and inherited\n * enumerable keyed properties of source objects into the destination object.\n *\n * NOTE: this behaves like lodash/merge, but:\n * - does mutate functions if they are a source\n * - treats non-plain objects as plain\n * - does not work for circular objects\n * - treats sparse arrays as sparse\n * - does not convert Array-like objects (Arguments, NodeLists, etc.) to arrays\n *\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n */\n\n\nfunction merge(target) {\n  if (!isObjectOrArrayOrFunction(target)) {\n    target = {};\n  }\n\n  for (var i = 1, l = arguments.length; i < l; i++) {\n    var source = arguments[i];\n\n    if (isObjectOrArrayOrFunction(source)) {\n      _merge(target, source);\n    }\n  }\n\n  return target;\n}\n\nmodule.exports = merge;","'use strict'; // @MAJOR can be replaced by native Array#find when we change support\n\nmodule.exports = function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return undefined;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return array[i];\n    }\n  }\n};","'use strict';\n/**\n * Functions to manipulate refinement lists\n *\n * The RefinementList is not formally defined through a prototype but is based\n * on a specific structure.\n *\n * @module SearchParameters.refinementList\n *\n * @typedef {string[]} SearchParameters.refinementList.Refinements\n * @typedef {Object.<string, SearchParameters.refinementList.Refinements>} SearchParameters.refinementList.RefinementList\n */\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar defaultsPure = require('../functions/defaultsPure');\n\nvar omit = require('../functions/omit');\n\nvar objectHasKeys = require('../functions/objectHasKeys');\n\nvar lib = {\n  /**\n   * Adds a refinement to a RefinementList\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} value the value of the refinement, if the value is not a string it will be converted\n   * @return {RefinementList} a new and updated refinement list\n   */\n  addRefinement: function addRefinement(refinementList, attribute, value) {\n    if (lib.isRefined(refinementList, attribute, value)) {\n      return refinementList;\n    }\n\n    var valueAsString = '' + value;\n    var facetRefinement = !refinementList[attribute] ? [valueAsString] : refinementList[attribute].concat(valueAsString);\n    var mod = {};\n    mod[attribute] = facetRefinement;\n    return defaultsPure({}, mod, refinementList);\n  },\n\n  /**\n   * Removes refinement(s) for an attribute:\n   *  - if the value is specified removes the refinement for the value on the attribute\n   *  - if no value is specified removes all the refinements for this attribute\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} [value] the value of the refinement\n   * @return {RefinementList} a new and updated refinement lst\n   */\n  removeRefinement: function removeRefinement(refinementList, attribute, value) {\n    if (value === undefined) {\n      // we use the \"filter\" form of clearRefinement, since it leaves empty values as-is\n      // the form with a string will remove the attribute completely\n      return lib.clearRefinement(refinementList, function (v, f) {\n        return attribute === f;\n      });\n    }\n\n    var valueAsString = '' + value;\n    return lib.clearRefinement(refinementList, function (v, f) {\n      return attribute === f && valueAsString === v;\n    });\n  },\n\n  /**\n   * Toggles the refinement value for an attribute.\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} value the value of the refinement\n   * @return {RefinementList} a new and updated list\n   */\n  toggleRefinement: function toggleRefinement(refinementList, attribute, value) {\n    if (value === undefined) throw new Error('toggleRefinement should be used with a value');\n\n    if (lib.isRefined(refinementList, attribute, value)) {\n      return lib.removeRefinement(refinementList, attribute, value);\n    }\n\n    return lib.addRefinement(refinementList, attribute, value);\n  },\n\n  /**\n   * Clear all or parts of a RefinementList. Depending on the arguments, three\n   * kinds of behavior can happen:\n   *  - if no attribute is provided: clears the whole list\n   *  - if an attribute is provided as a string: clears the list for the specific attribute\n   *  - if an attribute is provided as a function: discards the elements for which the function returns true\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} [attribute] the attribute or function to discard\n   * @param {string} [refinementType] optional parameter to give more context to the attribute function\n   * @return {RefinementList} a new and updated refinement list\n   */\n  clearRefinement: function clearRefinement(refinementList, attribute, refinementType) {\n    if (attribute === undefined) {\n      if (!objectHasKeys(refinementList)) {\n        return refinementList;\n      }\n\n      return {};\n    } else if (typeof attribute === 'string') {\n      return omit(refinementList, [attribute]);\n    } else if (typeof attribute === 'function') {\n      var hasChanged = false;\n      var newRefinementList = Object.keys(refinementList).reduce(function (memo, key) {\n        var values = refinementList[key] || [];\n        var facetList = values.filter(function (value) {\n          return !attribute(value, key, refinementType);\n        });\n\n        if (facetList.length !== values.length) {\n          hasChanged = true;\n        }\n\n        memo[key] = facetList;\n        return memo;\n      }, {});\n      if (hasChanged) return newRefinementList;\n      return refinementList;\n    }\n  },\n\n  /**\n   * Test if the refinement value is used for the attribute. If no refinement value\n   * is provided, test if the refinementList contains any refinement for the\n   * given attribute.\n   * @param {RefinementList} refinementList the list of refinement\n   * @param {string} attribute name of the attribute\n   * @param {string} [refinementValue] value of the filter/refinement\n   * @return {boolean}\n   */\n  isRefined: function isRefined(refinementList, attribute, refinementValue) {\n    var containsRefinements = !!refinementList[attribute] && refinementList[attribute].length > 0;\n\n    if (refinementValue === undefined || !containsRefinements) {\n      return containsRefinements;\n    }\n\n    var refinementValueAsString = '' + refinementValue;\n    return refinementList[attribute].indexOf(refinementValueAsString) !== -1;\n  }\n};\nmodule.exports = lib;","'use strict';\n\nvar events = require('events');\n\nvar inherits = require('../functions/inherits');\n/**\n * A DerivedHelper is a way to create sub requests to\n * Algolia from a main helper.\n * @class\n * @classdesc The DerivedHelper provides an event based interface for search callbacks:\n *  - search: when a search is triggered using the `search()` method.\n *  - result: when the response is retrieved from Algolia and is processed.\n *    This event contains a {@link SearchResults} object and the\n *    {@link SearchParameters} corresponding to this answer.\n */\n\n\nfunction DerivedHelper(mainHelper, fn) {\n  this.main = mainHelper;\n  this.fn = fn;\n  this.lastResults = null;\n}\n\ninherits(DerivedHelper, events.EventEmitter);\n/**\n * Detach this helper from the main helper\n * @return {undefined}\n * @throws Error if the derived helper is already detached\n */\n\nDerivedHelper.prototype.detach = function () {\n  this.removeAllListeners();\n  this.main.detachDerivedHelper(this);\n};\n\nDerivedHelper.prototype.getModifiedState = function (parameters) {\n  return this.fn(parameters);\n};\n\nmodule.exports = DerivedHelper;","'use strict';\n\nvar AlgoliaSearchHelper = require('./src/algoliasearch.helper');\n\nvar SearchParameters = require('./src/SearchParameters');\n\nvar SearchResults = require('./src/SearchResults');\n/**\n * The algoliasearchHelper module is the function that will let its\n * contains everything needed to use the Algoliasearch\n * Helper. It is a also a function that instanciate the helper.\n * To use the helper, you also need the Algolia JS client v3.\n * @example\n * //using the UMD build\n * var client = algoliasearch('latency', '6be0576ff61c053d5f9a3225e2a90f76');\n * var helper = algoliasearchHelper(client, 'bestbuy', {\n *   facets: ['shipping'],\n *   disjunctiveFacets: ['category']\n * });\n * helper.on('result', function(event) {\n *   console.log(event.results);\n * });\n * helper\n *   .toggleFacetRefinement('category', 'Movies & TV Shows')\n *   .toggleFacetRefinement('shipping', 'Free shipping')\n *   .search();\n * @example\n * // The helper is an event emitter using the node API\n * helper.on('result', updateTheResults);\n * helper.once('result', updateTheResults);\n * helper.removeListener('result', updateTheResults);\n * helper.removeAllListeners('result');\n * @module algoliasearchHelper\n * @param  {AlgoliaSearch} client an AlgoliaSearch client\n * @param  {string} index the name of the index to query\n * @param  {SearchParameters|object} opts an object defining the initial config of the search. It doesn't have to be a {SearchParameters}, just an object containing the properties you need from it.\n * @return {AlgoliaSearchHelper}\n */\n\n\nfunction algoliasearchHelper(client, index, opts) {\n  return new AlgoliaSearchHelper(client, index, opts);\n}\n/**\n * The version currently used\n * @member module:algoliasearchHelper.version\n * @type {number}\n */\n\n\nalgoliasearchHelper.version = require('./src/version.js');\n/**\n * Constructor for the Helper.\n * @member module:algoliasearchHelper.AlgoliaSearchHelper\n * @type {AlgoliaSearchHelper}\n */\n\nalgoliasearchHelper.AlgoliaSearchHelper = AlgoliaSearchHelper;\n/**\n * Constructor for the object containing all the parameters of the search.\n * @member module:algoliasearchHelper.SearchParameters\n * @type {SearchParameters}\n */\n\nalgoliasearchHelper.SearchParameters = SearchParameters;\n/**\n * Constructor for the object containing the results of the search.\n * @member module:algoliasearchHelper.SearchResults\n * @type {SearchResults}\n */\n\nalgoliasearchHelper.SearchResults = SearchResults;\nmodule.exports = algoliasearchHelper;","'use strict';\n\nfunction inherits(ctor, superCtor) {\n  ctor.prototype = Object.create(superCtor.prototype, {\n    constructor: {\n      value: ctor,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n}\n\nmodule.exports = inherits;","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar merge = require('../functions/merge');\n\nvar defaultsPure = require('../functions/defaultsPure');\n\nvar intersection = require('../functions/intersection');\n\nvar find = require('../functions/find');\n\nvar valToNumber = require('../functions/valToNumber');\n\nvar omit = require('../functions/omit');\n\nvar objectHasKeys = require('../functions/objectHasKeys');\n\nvar isValidUserToken = require('../utils/isValidUserToken');\n\nvar RefinementList = require('./RefinementList');\n/**\n * isEqual, but only for numeric refinement values, possible values:\n * - 5\n * - [5]\n * - [[5]]\n * - [[5,5],[4]]\n */\n\n\nfunction isEqualNumericRefinement(a, b) {\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every(function (el, i) {\n      return isEqualNumericRefinement(b[i], el);\n    });\n  }\n\n  return a === b;\n}\n/**\n * like _.find but using deep equality to be able to use it\n * to find arrays.\n * @private\n * @param {any[]} array array to search into (elements are base or array of base)\n * @param {any} searchedValue the value we're looking for (base or array of base)\n * @return {any} the searched value or undefined\n */\n\n\nfunction findArray(array, searchedValue) {\n  return find(array, function (currentValue) {\n    return isEqualNumericRefinement(currentValue, searchedValue);\n  });\n}\n/**\n * The facet list is the structure used to store the list of values used to\n * filter a single attribute.\n * @typedef {string[]} SearchParameters.FacetList\n */\n\n/**\n * Structure to store numeric filters with the operator as the key. The supported operators\n * are `=`, `>`, `<`, `>=`, `<=` and `!=`.\n * @typedef {Object.<string, Array.<number|number[]>>} SearchParameters.OperatorList\n */\n\n/**\n * SearchParameters is the data structure that contains all the information\n * usable for making a search to Algolia API. It doesn't do the search itself,\n * nor does it contains logic about the parameters.\n * It is an immutable object, therefore it has been created in a way that each\n * changes does not change the object itself but returns a copy with the\n * modification.\n * This object should probably not be instantiated outside of the helper. It will\n * be provided when needed. This object is documented for reference as you'll\n * get it from events generated by the {@link AlgoliaSearchHelper}.\n * If need be, instantiate the Helper from the factory function {@link SearchParameters.make}\n * @constructor\n * @classdesc contains all the parameters of a search\n * @param {object|SearchParameters} newParameters existing parameters or partial object\n * for the properties of a new SearchParameters\n * @see SearchParameters.make\n * @example <caption>SearchParameters of the first query in\n *   <a href=\"http://demos.algolia.com/instant-search-demo/\">the instant search demo</a></caption>\n{\n   \"query\": \"\",\n   \"disjunctiveFacets\": [\n      \"customerReviewCount\",\n      \"category\",\n      \"salePrice_range\",\n      \"manufacturer\"\n  ],\n   \"maxValuesPerFacet\": 30,\n   \"page\": 0,\n   \"hitsPerPage\": 10,\n   \"facets\": [\n      \"type\",\n      \"shipping\"\n  ]\n}\n */\n\n\nfunction SearchParameters(newParameters) {\n  var params = newParameters ? SearchParameters._parseNumbers(newParameters) : {};\n\n  if (params.userToken !== undefined && !isValidUserToken(params.userToken)) {\n    console.warn('[algoliasearch-helper] The `userToken` parameter is invalid. This can lead to wrong analytics.\\n  - Format: [a-zA-Z0-9_-]{1,64}');\n  }\n  /**\n   * This attribute contains the list of all the conjunctive facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * @member {string[]}\n   */\n\n\n  this.facets = params.facets || [];\n  /**\n   * This attribute contains the list of all the disjunctive facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * @member {string[]}\n   */\n\n  this.disjunctiveFacets = params.disjunctiveFacets || [];\n  /**\n   * This attribute contains the list of all the hierarchical facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * Hierarchical facets are a sub type of disjunctive facets that\n   * let you filter faceted attributes hierarchically.\n   * @member {string[]|object[]}\n   */\n\n  this.hierarchicalFacets = params.hierarchicalFacets || []; // Refinements\n\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the conjunctive facets. Each facet must be properly\n   * defined in the `facets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n\n  this.facetsRefinements = params.facetsRefinements || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * excluded from the conjunctive facets. Each facet must be properly\n   * defined in the `facets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters excluded for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n\n  this.facetsExcludes = params.facetsExcludes || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the disjunctive facets. Each facet must be properly\n   * defined in the `disjunctiveFacets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n\n  this.disjunctiveFacetsRefinements = params.disjunctiveFacetsRefinements || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the numeric attributes.\n   *\n   * The key is the name of the attribute, and the value is the\n   * filters to apply to this attribute.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `numericFilters` attribute.\n   * @member {Object.<string, SearchParameters.OperatorList>}\n   */\n\n  this.numericRefinements = params.numericRefinements || {};\n  /**\n   * This attribute contains all the tags used to refine the query.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `tagFilters` attribute.\n   * @member {string[]}\n   */\n\n  this.tagRefinements = params.tagRefinements || [];\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the hierarchical facets. Each facet must be properly\n   * defined in the `hierarchicalFacets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name. The FacetList values\n   * are structured as a string that contain the values for each level\n   * separated by the configured separator.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n\n  this.hierarchicalFacetsRefinements = params.hierarchicalFacetsRefinements || {};\n  var self = this;\n  Object.keys(params).forEach(function (paramName) {\n    var isKeyKnown = SearchParameters.PARAMETERS.indexOf(paramName) !== -1;\n    var isValueDefined = params[paramName] !== undefined;\n\n    if (!isKeyKnown && isValueDefined) {\n      self[paramName] = params[paramName];\n    }\n  });\n}\n/**\n * List all the properties in SearchParameters and therefore all the known Algolia properties\n * This doesn't contain any beta/hidden features.\n * @private\n */\n\n\nSearchParameters.PARAMETERS = Object.keys(new SearchParameters());\n/**\n * @private\n * @param {object} partialState full or part of a state\n * @return {object} a new object with the number keys as number\n */\n\nSearchParameters._parseNumbers = function (partialState) {\n  // Do not reparse numbers in SearchParameters, they ought to be parsed already\n  if (partialState instanceof SearchParameters) return partialState;\n  var numbers = {};\n  var numberKeys = ['aroundPrecision', 'aroundRadius', 'getRankingInfo', 'minWordSizefor2Typos', 'minWordSizefor1Typo', 'page', 'maxValuesPerFacet', 'distinct', 'minimumAroundRadius', 'hitsPerPage', 'minProximity'];\n  numberKeys.forEach(function (k) {\n    var value = partialState[k];\n\n    if (typeof value === 'string') {\n      var parsedValue = parseFloat(value); // global isNaN is ok to use here, value is only number or NaN\n\n      numbers[k] = isNaN(parsedValue) ? value : parsedValue;\n    }\n  }); // there's two formats of insideBoundingBox, we need to parse\n  // the one which is an array of float geo rectangles\n\n  if (Array.isArray(partialState.insideBoundingBox)) {\n    numbers.insideBoundingBox = partialState.insideBoundingBox.map(function (geoRect) {\n      if (Array.isArray(geoRect)) {\n        return geoRect.map(function (value) {\n          return parseFloat(value);\n        });\n      }\n\n      return geoRect;\n    });\n  }\n\n  if (partialState.numericRefinements) {\n    var numericRefinements = {};\n    Object.keys(partialState.numericRefinements).forEach(function (attribute) {\n      var operators = partialState.numericRefinements[attribute] || {};\n      numericRefinements[attribute] = {};\n      Object.keys(operators).forEach(function (operator) {\n        var values = operators[operator];\n        var parsedValues = values.map(function (v) {\n          if (Array.isArray(v)) {\n            return v.map(function (vPrime) {\n              if (typeof vPrime === 'string') {\n                return parseFloat(vPrime);\n              }\n\n              return vPrime;\n            });\n          } else if (typeof v === 'string') {\n            return parseFloat(v);\n          }\n\n          return v;\n        });\n        numericRefinements[attribute][operator] = parsedValues;\n      });\n    });\n    numbers.numericRefinements = numericRefinements;\n  }\n\n  return merge({}, partialState, numbers);\n};\n/**\n * Factory for SearchParameters\n * @param {object|SearchParameters} newParameters existing parameters or partial\n * object for the properties of a new SearchParameters\n * @return {SearchParameters} frozen instance of SearchParameters\n */\n\n\nSearchParameters.make = function makeSearchParameters(newParameters) {\n  var instance = new SearchParameters(newParameters);\n  var hierarchicalFacets = newParameters.hierarchicalFacets || [];\n  hierarchicalFacets.forEach(function (facet) {\n    if (facet.rootPath) {\n      var currentRefinement = instance.getHierarchicalRefinement(facet.name);\n\n      if (currentRefinement.length > 0 && currentRefinement[0].indexOf(facet.rootPath) !== 0) {\n        instance = instance.clearRefinements(facet.name);\n      } // get it again in case it has been cleared\n\n\n      currentRefinement = instance.getHierarchicalRefinement(facet.name);\n\n      if (currentRefinement.length === 0) {\n        instance = instance.toggleHierarchicalFacetRefinement(facet.name, facet.rootPath);\n      }\n    }\n  });\n  return instance;\n};\n/**\n * Validates the new parameters based on the previous state\n * @param {SearchParameters} currentState the current state\n * @param {object|SearchParameters} parameters the new parameters to set\n * @return {Error|null} Error if the modification is invalid, null otherwise\n */\n\n\nSearchParameters.validate = function (currentState, parameters) {\n  var params = parameters || {};\n\n  if (currentState.tagFilters && params.tagRefinements && params.tagRefinements.length > 0) {\n    return new Error('[Tags] Cannot switch from the managed tag API to the advanced API. It is probably ' + 'an error, if it is really what you want, you should first clear the tags with clearTags method.');\n  }\n\n  if (currentState.tagRefinements.length > 0 && params.tagFilters) {\n    return new Error('[Tags] Cannot switch from the advanced tag API to the managed API. It is probably ' + 'an error, if it is not, you should first clear the tags with clearTags method.');\n  }\n\n  if (currentState.numericFilters && params.numericRefinements && objectHasKeys(params.numericRefinements)) {\n    return new Error(\"[Numeric filters] Can't switch from the advanced to the managed API. It\" + ' is probably an error, if this is really what you want, you have to first' + ' clear the numeric filters.');\n  }\n\n  if (objectHasKeys(currentState.numericRefinements) && params.numericFilters) {\n    return new Error(\"[Numeric filters] Can't switch from the managed API to the advanced. It\" + ' is probably an error, if this is really what you want, you have to first' + ' clear the numeric filters.');\n  }\n\n  return null;\n};\n\nSearchParameters.prototype = {\n  constructor: SearchParameters,\n\n  /**\n   * Remove all refinements (disjunctive + conjunctive + excludes + numeric filters)\n   * @method\n   * @param {undefined|string|SearchParameters.clearCallback} [attribute] optional string or function\n   * - If not given, means to clear all the filters.\n   * - If `string`, means to clear all refinements for the `attribute` named filter.\n   * - If `function`, means to clear all the refinements that return truthy values.\n   * @return {SearchParameters}\n   */\n  clearRefinements: function clearRefinements(attribute) {\n    var patch = {\n      numericRefinements: this._clearNumericRefinements(attribute),\n      facetsRefinements: RefinementList.clearRefinement(this.facetsRefinements, attribute, 'conjunctiveFacet'),\n      facetsExcludes: RefinementList.clearRefinement(this.facetsExcludes, attribute, 'exclude'),\n      disjunctiveFacetsRefinements: RefinementList.clearRefinement(this.disjunctiveFacetsRefinements, attribute, 'disjunctiveFacet'),\n      hierarchicalFacetsRefinements: RefinementList.clearRefinement(this.hierarchicalFacetsRefinements, attribute, 'hierarchicalFacet')\n    };\n\n    if (patch.numericRefinements === this.numericRefinements && patch.facetsRefinements === this.facetsRefinements && patch.facetsExcludes === this.facetsExcludes && patch.disjunctiveFacetsRefinements === this.disjunctiveFacetsRefinements && patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements) {\n      return this;\n    }\n\n    return this.setQueryParameters(patch);\n  },\n\n  /**\n   * Remove all the refined tags from the SearchParameters\n   * @method\n   * @return {SearchParameters}\n   */\n  clearTags: function clearTags() {\n    if (this.tagFilters === undefined && this.tagRefinements.length === 0) return this;\n    return this.setQueryParameters({\n      tagFilters: undefined,\n      tagRefinements: []\n    });\n  },\n\n  /**\n   * Set the index.\n   * @method\n   * @param {string} index the index name\n   * @return {SearchParameters}\n   */\n  setIndex: function setIndex(index) {\n    if (index === this.index) return this;\n    return this.setQueryParameters({\n      index: index\n    });\n  },\n\n  /**\n   * Query setter\n   * @method\n   * @param {string} newQuery value for the new query\n   * @return {SearchParameters}\n   */\n  setQuery: function setQuery(newQuery) {\n    if (newQuery === this.query) return this;\n    return this.setQueryParameters({\n      query: newQuery\n    });\n  },\n\n  /**\n   * Page setter\n   * @method\n   * @param {number} newPage new page number\n   * @return {SearchParameters}\n   */\n  setPage: function setPage(newPage) {\n    if (newPage === this.page) return this;\n    return this.setQueryParameters({\n      page: newPage\n    });\n  },\n\n  /**\n   * Facets setter\n   * The facets are the simple facets, used for conjunctive (and) faceting.\n   * @method\n   * @param {string[]} facets all the attributes of the algolia records used for conjunctive faceting\n   * @return {SearchParameters}\n   */\n  setFacets: function setFacets(facets) {\n    return this.setQueryParameters({\n      facets: facets\n    });\n  },\n\n  /**\n   * Disjunctive facets setter\n   * Change the list of disjunctive (or) facets the helper chan handle.\n   * @method\n   * @param {string[]} facets all the attributes of the algolia records used for disjunctive faceting\n   * @return {SearchParameters}\n   */\n  setDisjunctiveFacets: function setDisjunctiveFacets(facets) {\n    return this.setQueryParameters({\n      disjunctiveFacets: facets\n    });\n  },\n\n  /**\n   * HitsPerPage setter\n   * Hits per page represents the number of hits retrieved for this query\n   * @method\n   * @param {number} n number of hits retrieved per page of results\n   * @return {SearchParameters}\n   */\n  setHitsPerPage: function setHitsPerPage(n) {\n    if (this.hitsPerPage === n) return this;\n    return this.setQueryParameters({\n      hitsPerPage: n\n    });\n  },\n\n  /**\n   * typoTolerance setter\n   * Set the value of typoTolerance\n   * @method\n   * @param {string} typoTolerance new value of typoTolerance (\"true\", \"false\", \"min\" or \"strict\")\n   * @return {SearchParameters}\n   */\n  setTypoTolerance: function setTypoTolerance(typoTolerance) {\n    if (this.typoTolerance === typoTolerance) return this;\n    return this.setQueryParameters({\n      typoTolerance: typoTolerance\n    });\n  },\n\n  /**\n   * Add a numeric filter for a given attribute\n   * When value is an array, they are combined with OR\n   * When value is a single value, it will combined with AND\n   * @method\n   * @param {string} attribute attribute to set the filter on\n   * @param {string} operator operator of the filter (possible values: =, >, >=, <, <=, !=)\n   * @param {number | number[]} value value of the filter\n   * @return {SearchParameters}\n   * @example\n   * // for price = 50 or 40\n   * searchparameter.addNumericRefinement('price', '=', [50, 40]);\n   * @example\n   * // for size = 38 and 40\n   * searchparameter.addNumericRefinement('size', '=', 38);\n   * searchparameter.addNumericRefinement('size', '=', 40);\n   */\n  addNumericRefinement: function addNumericRefinement(attribute, operator, v) {\n    var value = valToNumber(v);\n    if (this.isNumericRefined(attribute, operator, value)) return this;\n    var mod = merge({}, this.numericRefinements);\n    mod[attribute] = merge({}, mod[attribute]);\n\n    if (mod[attribute][operator]) {\n      // Array copy\n      mod[attribute][operator] = mod[attribute][operator].slice(); // Add the element. Concat can't be used here because value can be an array.\n\n      mod[attribute][operator].push(value);\n    } else {\n      mod[attribute][operator] = [value];\n    }\n\n    return this.setQueryParameters({\n      numericRefinements: mod\n    });\n  },\n\n  /**\n   * Get the list of conjunctive refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getConjunctiveRefinements: function getConjunctiveRefinements(facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      return [];\n    }\n\n    return this.facetsRefinements[facetName] || [];\n  },\n\n  /**\n   * Get the list of disjunctive refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getDisjunctiveRefinements: function getDisjunctiveRefinements(facetName) {\n    if (!this.isDisjunctiveFacet(facetName)) {\n      return [];\n    }\n\n    return this.disjunctiveFacetsRefinements[facetName] || [];\n  },\n\n  /**\n   * Get the list of hierarchical refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getHierarchicalRefinement: function getHierarchicalRefinement(facetName) {\n    // we send an array but we currently do not support multiple\n    // hierarchicalRefinements for a hierarchicalFacet\n    return this.hierarchicalFacetsRefinements[facetName] || [];\n  },\n\n  /**\n   * Get the list of exclude refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getExcludeRefinements: function getExcludeRefinements(facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      return [];\n    }\n\n    return this.facetsExcludes[facetName] || [];\n  },\n\n  /**\n   * Remove all the numeric filter for a given (attribute, operator)\n   * @method\n   * @param {string} attribute attribute to set the filter on\n   * @param {string} [operator] operator of the filter (possible values: =, >, >=, <, <=, !=)\n   * @param {number} [number] the value to be removed\n   * @return {SearchParameters}\n   */\n  removeNumericRefinement: function removeNumericRefinement(attribute, operator, paramValue) {\n    if (paramValue !== undefined) {\n      if (!this.isNumericRefined(attribute, operator, paramValue)) {\n        return this;\n      }\n\n      return this.setQueryParameters({\n        numericRefinements: this._clearNumericRefinements(function (value, key) {\n          return key === attribute && value.op === operator && isEqualNumericRefinement(value.val, valToNumber(paramValue));\n        })\n      });\n    } else if (operator !== undefined) {\n      if (!this.isNumericRefined(attribute, operator)) return this;\n      return this.setQueryParameters({\n        numericRefinements: this._clearNumericRefinements(function (value, key) {\n          return key === attribute && value.op === operator;\n        })\n      });\n    }\n\n    if (!this.isNumericRefined(attribute)) return this;\n    return this.setQueryParameters({\n      numericRefinements: this._clearNumericRefinements(function (value, key) {\n        return key === attribute;\n      })\n    });\n  },\n\n  /**\n   * Get the list of numeric refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {SearchParameters.OperatorList} list of refinements\n   */\n  getNumericRefinements: function getNumericRefinements(facetName) {\n    return this.numericRefinements[facetName] || {};\n  },\n\n  /**\n   * Return the current refinement for the (attribute, operator)\n   * @param {string} attribute attribute in the record\n   * @param {string} operator operator applied on the refined values\n   * @return {Array.<number|number[]>} refined values\n   */\n  getNumericRefinement: function getNumericRefinement(attribute, operator) {\n    return this.numericRefinements[attribute] && this.numericRefinements[attribute][operator];\n  },\n\n  /**\n   * Clear numeric filters.\n   * @method\n   * @private\n   * @param {string|SearchParameters.clearCallback} [attribute] optional string or function\n   * - If not given, means to clear all the filters.\n   * - If `string`, means to clear all refinements for the `attribute` named filter.\n   * - If `function`, means to clear all the refinements that return truthy values.\n   * @return {Object.<string, OperatorList>}\n   */\n  _clearNumericRefinements: function _clearNumericRefinements(attribute) {\n    if (attribute === undefined) {\n      if (!objectHasKeys(this.numericRefinements)) {\n        return this.numericRefinements;\n      }\n\n      return {};\n    } else if (typeof attribute === 'string') {\n      return omit(this.numericRefinements, [attribute]);\n    } else if (typeof attribute === 'function') {\n      var hasChanged = false;\n      var numericRefinements = this.numericRefinements;\n      var newNumericRefinements = Object.keys(numericRefinements).reduce(function (memo, key) {\n        var operators = numericRefinements[key];\n        var operatorList = {};\n        operators = operators || {};\n        Object.keys(operators).forEach(function (operator) {\n          var values = operators[operator] || [];\n          var outValues = [];\n          values.forEach(function (value) {\n            var predicateResult = attribute({\n              val: value,\n              op: operator\n            }, key, 'numeric');\n            if (!predicateResult) outValues.push(value);\n          });\n\n          if (outValues.length !== values.length) {\n            hasChanged = true;\n          }\n\n          operatorList[operator] = outValues;\n        });\n        memo[key] = operatorList;\n        return memo;\n      }, {});\n      if (hasChanged) return newNumericRefinements;\n      return this.numericRefinements;\n    }\n  },\n\n  /**\n   * Add a facet to the facets attribute of the helper configuration, if it\n   * isn't already present.\n   * @method\n   * @param {string} facet facet name to add\n   * @return {SearchParameters}\n   */\n  addFacet: function addFacet(facet) {\n    if (this.isConjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.setQueryParameters({\n      facets: this.facets.concat([facet])\n    });\n  },\n\n  /**\n   * Add a disjunctive facet to the disjunctiveFacets attribute of the helper\n   * configuration, if it isn't already present.\n   * @method\n   * @param {string} facet disjunctive facet name to add\n   * @return {SearchParameters}\n   */\n  addDisjunctiveFacet: function addDisjunctiveFacet(facet) {\n    if (this.isDisjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.setQueryParameters({\n      disjunctiveFacets: this.disjunctiveFacets.concat([facet])\n    });\n  },\n\n  /**\n   * Add a hierarchical facet to the hierarchicalFacets attribute of the helper\n   * configuration.\n   * @method\n   * @param {object} hierarchicalFacet hierarchical facet to add\n   * @return {SearchParameters}\n   * @throws will throw an error if a hierarchical facet with the same name was already declared\n   */\n  addHierarchicalFacet: function addHierarchicalFacet(hierarchicalFacet) {\n    if (this.isHierarchicalFacet(hierarchicalFacet.name)) {\n      throw new Error('Cannot declare two hierarchical facets with the same name: `' + hierarchicalFacet.name + '`');\n    }\n\n    return this.setQueryParameters({\n      hierarchicalFacets: this.hierarchicalFacets.concat([hierarchicalFacet])\n    });\n  },\n\n  /**\n   * Add a refinement on a \"normal\" facet\n   * @method\n   * @param {string} facet attribute to apply the faceting on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters}\n   */\n  addFacetRefinement: function addFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    if (RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.addRefinement(this.facetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Exclude a value from a \"normal\" facet\n   * @method\n   * @param {string} facet attribute to apply the exclusion on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters}\n   */\n  addExcludeRefinement: function addExcludeRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    if (RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.addRefinement(this.facetsExcludes, facet, value)\n    });\n  },\n\n  /**\n   * Adds a refinement on a disjunctive facet.\n   * @method\n   * @param {string} facet attribute to apply the faceting on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters}\n   */\n  addDisjunctiveFacetRefinement: function addDisjunctiveFacetRefinement(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n\n    if (RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.addRefinement(this.disjunctiveFacetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * addTagRefinement adds a tag to the list used to filter the results\n   * @param {string} tag tag to be added\n   * @return {SearchParameters}\n   */\n  addTagRefinement: function addTagRefinement(tag) {\n    if (this.isTagRefined(tag)) return this;\n    var modification = {\n      tagRefinements: this.tagRefinements.concat(tag)\n    };\n    return this.setQueryParameters(modification);\n  },\n\n  /**\n   * Remove a facet from the facets attribute of the helper configuration, if it\n   * is present.\n   * @method\n   * @param {string} facet facet name to remove\n   * @return {SearchParameters}\n   */\n  removeFacet: function removeFacet(facet) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      facets: this.facets.filter(function (f) {\n        return f !== facet;\n      })\n    });\n  },\n\n  /**\n   * Remove a disjunctive facet from the disjunctiveFacets attribute of the\n   * helper configuration, if it is present.\n   * @method\n   * @param {string} facet disjunctive facet name to remove\n   * @return {SearchParameters}\n   */\n  removeDisjunctiveFacet: function removeDisjunctiveFacet(facet) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      disjunctiveFacets: this.disjunctiveFacets.filter(function (f) {\n        return f !== facet;\n      })\n    });\n  },\n\n  /**\n   * Remove a hierarchical facet from the hierarchicalFacets attribute of the\n   * helper configuration, if it is present.\n   * @method\n   * @param {string} facet hierarchical facet name to remove\n   * @return {SearchParameters}\n   */\n  removeHierarchicalFacet: function removeHierarchicalFacet(facet) {\n    if (!this.isHierarchicalFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      hierarchicalFacets: this.hierarchicalFacets.filter(function (f) {\n        return f.name !== facet;\n      })\n    });\n  },\n\n  /**\n   * Remove a refinement set on facet. If a value is provided, it will clear the\n   * refinement for the given value, otherwise it will clear all the refinement\n   * values for the faceted attribute.\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} [value] value used to filter\n   * @return {SearchParameters}\n   */\n  removeFacetRefinement: function removeFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    if (!RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.removeRefinement(this.facetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Remove a negative refinement on a facet\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} value value used to filter\n   * @return {SearchParameters}\n   */\n  removeExcludeRefinement: function removeExcludeRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    if (!RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.removeRefinement(this.facetsExcludes, facet, value)\n    });\n  },\n\n  /**\n   * Remove a refinement on a disjunctive facet\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} value value used to filter\n   * @return {SearchParameters}\n   */\n  removeDisjunctiveFacetRefinement: function removeDisjunctiveFacetRefinement(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n\n    if (!RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.removeRefinement(this.disjunctiveFacetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Remove a tag from the list of tag refinements\n   * @method\n   * @param {string} tag the tag to remove\n   * @return {SearchParameters}\n   */\n  removeTagRefinement: function removeTagRefinement(tag) {\n    if (!this.isTagRefined(tag)) return this;\n    var modification = {\n      tagRefinements: this.tagRefinements.filter(function (t) {\n        return t !== tag;\n      })\n    };\n    return this.setQueryParameters(modification);\n  },\n\n  /**\n   * Generic toggle refinement method to use with facet, disjunctive facets\n   * and hierarchical facets\n   * @param  {string} facet the facet to refine\n   * @param  {string} value the associated value\n   * @return {SearchParameters}\n   * @throws will throw an error if the facet is not declared in the settings of the helper\n   * @deprecated since version 2.19.0, see {@link SearchParameters#toggleFacetRefinement}\n   */\n  toggleRefinement: function toggleRefinement(facet, value) {\n    return this.toggleFacetRefinement(facet, value);\n  },\n\n  /**\n   * Generic toggle refinement method to use with facet, disjunctive facets\n   * and hierarchical facets\n   * @param  {string} facet the facet to refine\n   * @param  {string} value the associated value\n   * @return {SearchParameters}\n   * @throws will throw an error if the facet is not declared in the settings of the helper\n   */\n  toggleFacetRefinement: function toggleFacetRefinement(facet, value) {\n    if (this.isHierarchicalFacet(facet)) {\n      return this.toggleHierarchicalFacetRefinement(facet, value);\n    } else if (this.isConjunctiveFacet(facet)) {\n      return this.toggleConjunctiveFacetRefinement(facet, value);\n    } else if (this.isDisjunctiveFacet(facet)) {\n      return this.toggleDisjunctiveFacetRefinement(facet, value);\n    }\n\n    throw new Error('Cannot refine the undeclared facet ' + facet + '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets');\n  },\n\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.toggleRefinement(this.facetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.toggleRefinement(this.facetsExcludes, facet, value)\n    });\n  },\n\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleDisjunctiveFacetRefinement: function toggleDisjunctiveFacetRefinement(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.toggleRefinement(this.disjunctiveFacetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleHierarchicalFacetRefinement: function toggleHierarchicalFacetRefinement(facet, value) {\n    if (!this.isHierarchicalFacet(facet)) {\n      throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration');\n    }\n\n    var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facet));\n\n    var mod = {};\n    var upOneOrMultipleLevel = this.hierarchicalFacetsRefinements[facet] !== undefined && this.hierarchicalFacetsRefinements[facet].length > 0 && ( // remove current refinement:\n    // refinement was 'beer > IPA', call is toggleRefine('beer > IPA'), refinement should be `beer`\n    this.hierarchicalFacetsRefinements[facet][0] === value || // remove a parent refinement of the current refinement:\n    //  - refinement was 'beer > IPA > Flying dog'\n    //  - call is toggleRefine('beer > IPA')\n    //  - refinement should be `beer`\n    this.hierarchicalFacetsRefinements[facet][0].indexOf(value + separator) === 0);\n\n    if (upOneOrMultipleLevel) {\n      if (value.indexOf(separator) === -1) {\n        // go back to root level\n        mod[facet] = [];\n      } else {\n        mod[facet] = [value.slice(0, value.lastIndexOf(separator))];\n      }\n    } else {\n      mod[facet] = [value];\n    }\n\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)\n    });\n  },\n\n  /**\n   * Adds a refinement on a hierarchical facet.\n   * @param {string} facet the facet name\n   * @param {string} path the hierarchical facet path\n   * @return {SearchParameter} the new state\n   * @throws Error if the facet is not defined or if the facet is refined\n   */\n  addHierarchicalFacetRefinement: function addHierarchicalFacetRefinement(facet, path) {\n    if (this.isHierarchicalFacetRefined(facet)) {\n      throw new Error(facet + ' is already refined.');\n    }\n\n    if (!this.isHierarchicalFacet(facet)) {\n      throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration.');\n    }\n\n    var mod = {};\n    mod[facet] = [path];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)\n    });\n  },\n\n  /**\n   * Removes the refinement set on a hierarchical facet.\n   * @param {string} facet the facet name\n   * @return {SearchParameter} the new state\n   * @throws Error if the facet is not defined or if the facet is not refined\n   */\n  removeHierarchicalFacetRefinement: function removeHierarchicalFacetRefinement(facet) {\n    if (!this.isHierarchicalFacetRefined(facet)) {\n      return this;\n    }\n\n    var mod = {};\n    mod[facet] = [];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)\n    });\n  },\n\n  /**\n   * Switch the tag refinement\n   * @method\n   * @param {string} tag the tag to remove or add\n   * @return {SearchParameters}\n   */\n  toggleTagRefinement: function toggleTagRefinement(tag) {\n    if (this.isTagRefined(tag)) {\n      return this.removeTagRefinement(tag);\n    }\n\n    return this.addTagRefinement(tag);\n  },\n\n  /**\n   * Test if the facet name is from one of the disjunctive facets\n   * @method\n   * @param {string} facet facet name to test\n   * @return {boolean}\n   */\n  isDisjunctiveFacet: function isDisjunctiveFacet(facet) {\n    return this.disjunctiveFacets.indexOf(facet) > -1;\n  },\n\n  /**\n   * Test if the facet name is from one of the hierarchical facets\n   * @method\n   * @param {string} facetName facet name to test\n   * @return {boolean}\n   */\n  isHierarchicalFacet: function isHierarchicalFacet(facetName) {\n    return this.getHierarchicalFacetByName(facetName) !== undefined;\n  },\n\n  /**\n   * Test if the facet name is from one of the conjunctive/normal facets\n   * @method\n   * @param {string} facet facet name to test\n   * @return {boolean}\n   */\n  isConjunctiveFacet: function isConjunctiveFacet(facet) {\n    return this.facets.indexOf(facet) > -1;\n  },\n\n  /**\n   * Returns true if the facet is refined, either for a specific value or in\n   * general.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value, optional value. If passed will test that this value\n   * is filtering the given facet.\n   * @return {boolean} returns true if refined\n   */\n  isFacetRefined: function isFacetRefined(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return false;\n    }\n\n    return RefinementList.isRefined(this.facetsRefinements, facet, value);\n  },\n\n  /**\n   * Returns true if the facet contains exclusions or if a specific value is\n   * excluded.\n   *\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} [value] optional value. If passed will test that this value\n   * is filtering the given facet.\n   * @return {boolean} returns true if refined\n   */\n  isExcludeRefined: function isExcludeRefined(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return false;\n    }\n\n    return RefinementList.isRefined(this.facetsExcludes, facet, value);\n  },\n\n  /**\n   * Returns true if the facet contains a refinement, or if a value passed is a\n   * refinement for the facet.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value optional, will test if the value is used for refinement\n   * if there is one, otherwise will test if the facet contains any refinement\n   * @return {boolean}\n   */\n  isDisjunctiveFacetRefined: function isDisjunctiveFacetRefined(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      return false;\n    }\n\n    return RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value);\n  },\n\n  /**\n   * Returns true if the facet contains a refinement, or if a value passed is a\n   * refinement for the facet.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value optional, will test if the value is used for refinement\n   * if there is one, otherwise will test if the facet contains any refinement\n   * @return {boolean}\n   */\n  isHierarchicalFacetRefined: function isHierarchicalFacetRefined(facet, value) {\n    if (!this.isHierarchicalFacet(facet)) {\n      return false;\n    }\n\n    var refinements = this.getHierarchicalRefinement(facet);\n\n    if (!value) {\n      return refinements.length > 0;\n    }\n\n    return refinements.indexOf(value) !== -1;\n  },\n\n  /**\n   * Test if the triple (attribute, operator, value) is already refined.\n   * If only the attribute and the operator are provided, it tests if the\n   * contains any refinement value.\n   * @method\n   * @param {string} attribute attribute for which the refinement is applied\n   * @param {string} [operator] operator of the refinement\n   * @param {string} [value] value of the refinement\n   * @return {boolean} true if it is refined\n   */\n  isNumericRefined: function isNumericRefined(attribute, operator, value) {\n    if (value === undefined && operator === undefined) {\n      return !!this.numericRefinements[attribute];\n    }\n\n    var isOperatorDefined = this.numericRefinements[attribute] && this.numericRefinements[attribute][operator] !== undefined;\n\n    if (value === undefined || !isOperatorDefined) {\n      return isOperatorDefined;\n    }\n\n    var parsedValue = valToNumber(value);\n    var isAttributeValueDefined = findArray(this.numericRefinements[attribute][operator], parsedValue) !== undefined;\n    return isOperatorDefined && isAttributeValueDefined;\n  },\n\n  /**\n   * Returns true if the tag refined, false otherwise\n   * @method\n   * @param {string} tag the tag to check\n   * @return {boolean}\n   */\n  isTagRefined: function isTagRefined(tag) {\n    return this.tagRefinements.indexOf(tag) !== -1;\n  },\n\n  /**\n   * Returns the list of all disjunctive facets refined\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {string[]}\n   */\n  getRefinedDisjunctiveFacets: function getRefinedDisjunctiveFacets() {\n    var self = this; // attributes used for numeric filter can also be disjunctive\n\n    var disjunctiveNumericRefinedFacets = intersection(Object.keys(this.numericRefinements).filter(function (facet) {\n      return Object.keys(self.numericRefinements[facet]).length > 0;\n    }), this.disjunctiveFacets);\n    return Object.keys(this.disjunctiveFacetsRefinements).filter(function (facet) {\n      return self.disjunctiveFacetsRefinements[facet].length > 0;\n    }).concat(disjunctiveNumericRefinedFacets).concat(this.getRefinedHierarchicalFacets());\n  },\n\n  /**\n   * Returns the list of all disjunctive facets refined\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {string[]}\n   */\n  getRefinedHierarchicalFacets: function getRefinedHierarchicalFacets() {\n    var self = this;\n    return intersection( // enforce the order between the two arrays,\n    // so that refinement name index === hierarchical facet index\n    this.hierarchicalFacets.map(function (facet) {\n      return facet.name;\n    }), Object.keys(this.hierarchicalFacetsRefinements).filter(function (facet) {\n      return self.hierarchicalFacetsRefinements[facet].length > 0;\n    }));\n  },\n\n  /**\n   * Returned the list of all disjunctive facets not refined\n   * @method\n   * @return {string[]}\n   */\n  getUnrefinedDisjunctiveFacets: function getUnrefinedDisjunctiveFacets() {\n    var refinedFacets = this.getRefinedDisjunctiveFacets();\n    return this.disjunctiveFacets.filter(function (f) {\n      return refinedFacets.indexOf(f) === -1;\n    });\n  },\n  managedParameters: ['index', 'facets', 'disjunctiveFacets', 'facetsRefinements', 'facetsExcludes', 'disjunctiveFacetsRefinements', 'numericRefinements', 'tagRefinements', 'hierarchicalFacets', 'hierarchicalFacetsRefinements'],\n  getQueryParams: function getQueryParams() {\n    var managedParameters = this.managedParameters;\n    var queryParams = {};\n    var self = this;\n    Object.keys(this).forEach(function (paramName) {\n      var paramValue = self[paramName];\n\n      if (managedParameters.indexOf(paramName) === -1 && paramValue !== undefined) {\n        queryParams[paramName] = paramValue;\n      }\n    });\n    return queryParams;\n  },\n\n  /**\n   * Let the user set a specific value for a given parameter. Will return the\n   * same instance if the parameter is invalid or if the value is the same as the\n   * previous one.\n   * @method\n   * @param {string} parameter the parameter name\n   * @param {any} value the value to be set, must be compliant with the definition\n   * of the attribute on the object\n   * @return {SearchParameters} the updated state\n   */\n  setQueryParameter: function setParameter(parameter, value) {\n    if (this[parameter] === value) return this;\n    var modification = {};\n    modification[parameter] = value;\n    return this.setQueryParameters(modification);\n  },\n\n  /**\n   * Let the user set any of the parameters with a plain object.\n   * @method\n   * @param {object} params all the keys and the values to be updated\n   * @return {SearchParameters} a new updated instance\n   */\n  setQueryParameters: function setQueryParameters(params) {\n    if (!params) return this;\n    var error = SearchParameters.validate(this, params);\n\n    if (error) {\n      throw error;\n    }\n\n    var self = this;\n\n    var nextWithNumbers = SearchParameters._parseNumbers(params);\n\n    var previousPlainObject = Object.keys(this).reduce(function (acc, key) {\n      acc[key] = self[key];\n      return acc;\n    }, {});\n    var nextPlainObject = Object.keys(nextWithNumbers).reduce(function (previous, key) {\n      var isPreviousValueDefined = previous[key] !== undefined;\n      var isNextValueDefined = nextWithNumbers[key] !== undefined;\n\n      if (isPreviousValueDefined && !isNextValueDefined) {\n        return omit(previous, [key]);\n      }\n\n      if (isNextValueDefined) {\n        previous[key] = nextWithNumbers[key];\n      }\n\n      return previous;\n    }, previousPlainObject);\n    return new this.constructor(nextPlainObject);\n  },\n\n  /**\n   * Returns a new instance with the page reset. Two scenarios possible:\n   * the page is omitted -> return the given instance\n   * the page is set -> return a new instance with a page of 0\n   * @return {SearchParameters} a new updated instance\n   */\n  resetPage: function resetPage() {\n    if (this.page === undefined) {\n      return this;\n    }\n\n    return this.setPage(0);\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet separator or the default one (`>`)\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.separator or `>` as default\n   */\n  _getHierarchicalFacetSortBy: function _getHierarchicalFacetSortBy(hierarchicalFacet) {\n    return hierarchicalFacet.sortBy || ['isRefined:desc', 'name:asc'];\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet separator or the default one (`>`)\n   * @private\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.separator or `>` as default\n   */\n  _getHierarchicalFacetSeparator: function _getHierarchicalFacetSeparator(hierarchicalFacet) {\n    return hierarchicalFacet.separator || ' > ';\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet prefix path or null\n   * @private\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.rootPath or null as default\n   */\n  _getHierarchicalRootPath: function _getHierarchicalRootPath(hierarchicalFacet) {\n    return hierarchicalFacet.rootPath || null;\n  },\n\n  /**\n   * Helper function to check if we show the parent level of the hierarchicalFacet\n   * @private\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.showParentLevel or true as default\n   */\n  _getHierarchicalShowParentLevel: function _getHierarchicalShowParentLevel(hierarchicalFacet) {\n    if (typeof hierarchicalFacet.showParentLevel === 'boolean') {\n      return hierarchicalFacet.showParentLevel;\n    }\n\n    return true;\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet by it's name\n   * @param  {string} hierarchicalFacetName\n   * @return {object} a hierarchicalFacet\n   */\n  getHierarchicalFacetByName: function getHierarchicalFacetByName(hierarchicalFacetName) {\n    return find(this.hierarchicalFacets, function (f) {\n      return f.name === hierarchicalFacetName;\n    });\n  },\n\n  /**\n   * Get the current breadcrumb for a hierarchical facet, as an array\n   * @param  {string} facetName Hierarchical facet name\n   * @return {array.<string>} the path as an array of string\n   */\n  getHierarchicalFacetBreadcrumb: function getHierarchicalFacetBreadcrumb(facetName) {\n    if (!this.isHierarchicalFacet(facetName)) {\n      return [];\n    }\n\n    var refinement = this.getHierarchicalRefinement(facetName)[0];\n    if (!refinement) return [];\n\n    var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facetName));\n\n    var path = refinement.split(separator);\n    return path.map(function (part) {\n      return part.trim();\n    });\n  },\n  toString: function toString() {\n    return JSON.stringify(this, null, 2);\n  }\n};\n/**\n * Callback used for clearRefinement method\n * @callback SearchParameters.clearCallback\n * @param {OperatorList|FacetList} value the value of the filter\n * @param {string} key the current attribute name\n * @param {string} type `numeric`, `disjunctiveFacet`, `conjunctiveFacet`, `hierarchicalFacet` or `exclude`\n * depending on the type of facet\n * @return {boolean} `true` if the element should be removed. `false` otherwise.\n */\n\nmodule.exports = SearchParameters;","'use strict';\n\nfunction intersection(arr1, arr2) {\n  return arr1.filter(function (value, index) {\n    return arr2.indexOf(value) > -1 && arr1.indexOf(value) === index\n    /* skips duplicates */\n    ;\n  });\n}\n\nmodule.exports = intersection;","'use strict';\n\nmodule.exports = function isValidUserToken(userToken) {\n  if (userToken === null) {\n    return false;\n  }\n\n  return /^[a-zA-Z0-9_-]{1,64}$/.test(userToken);\n};","'use strict';\n\nmodule.exports = function compact(array) {\n  if (!Array.isArray(array)) {\n    return [];\n  }\n\n  return array.filter(Boolean);\n};","/* global Map:readonly, Set:readonly, ArrayBuffer:readonly */\nvar hasElementType = typeof Element !== 'undefined';\nvar hasMap = typeof Map === 'function';\nvar hasSet = typeof Set === 'function';\nvar hasArrayBuffer = typeof ArrayBuffer === 'function' && !!ArrayBuffer.isView; // Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js\n\nfunction equal(a, b) {\n  // START: fast-deep-equal es6/index.js 3.1.1\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n    var length, i, keys;\n\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n\n      for (i = length; i-- !== 0;) {\n        if (!equal(a[i], b[i])) return false;\n      }\n\n      return true;\n    } // START: Modifications:\n    // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code\n    //    to co-exist with es5.\n    // 2. Replace `for of` with es5 compliant iteration using `for`.\n    //    Basically, take:\n    //\n    //    ```js\n    //    for (i of a.entries())\n    //      if (!b.has(i[0])) return false;\n    //    ```\n    //\n    //    ... and convert to:\n    //\n    //    ```js\n    //    it = a.entries();\n    //    while (!(i = it.next()).done)\n    //      if (!b.has(i.value[0])) return false;\n    //    ```\n    //\n    //    **Note**: `i` access switches to `i.value`.\n\n\n    var it;\n\n    if (hasMap && a instanceof Map && b instanceof Map) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n\n      while (!(i = it.next()).done) {\n        if (!b.has(i.value[0])) return false;\n      }\n\n      it = a.entries();\n\n      while (!(i = it.next()).done) {\n        if (!equal(i.value[1], b.get(i.value[0]))) return false;\n      }\n\n      return true;\n    }\n\n    if (hasSet && a instanceof Set && b instanceof Set) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n\n      while (!(i = it.next()).done) {\n        if (!b.has(i.value[0])) return false;\n      }\n\n      return true;\n    } // END: Modifications\n\n\n    if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n\n      for (i = length; i-- !== 0;) {\n        if (a[i] !== b[i]) return false;\n      }\n\n      return true;\n    }\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;) {\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n    } // END: fast-deep-equal\n    // START: react-fast-compare\n    // custom handling for DOM elements\n\n\n    if (hasElementType && a instanceof Element) return false; // custom handling for React/Preact\n\n    for (i = length; i-- !== 0;) {\n      if ((keys[i] === '_owner' || keys[i] === '__v' || keys[i] === '__o') && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner\n        // Preact-specific: avoid traversing Preact elements' __v and __o\n        //    __v = $_original / $_vnode\n        //    __o = $_owner\n        // These properties contain circular references and are not needed when\n        // comparing the actual elements (and not their owners)\n        // .$$typeof and ._store on just reasonable markers of elements\n        continue;\n      } // all other properties should be traversed as usual\n\n\n      if (!equal(a[keys[i]], b[keys[i]])) return false;\n    } // END: react-fast-compare\n    // START: fast-deep-equal\n\n\n    return true;\n  }\n\n  return a !== a && b !== b;\n} // end fast-deep-equal\n\n\nmodule.exports = function isEqual(a, b) {\n  try {\n    return equal(a, b);\n  } catch (error) {\n    if ((error.message || '').match(/stack|recursion/i)) {\n      // warn on circular references, don't crash\n      // browsers give this different errors name and messages:\n      // chrome/safari: \"RangeError\", \"Maximum call stack size exceeded\"\n      // firefox: \"InternalError\", too much recursion\"\n      // edge: \"Error\", \"Out of stack space\"\n      console.warn('react-fast-compare cannot handle circular refs');\n      return false;\n    } // some other error. we should definitely know about these\n\n\n    throw error;\n  }\n};","'use strict';\n\nfunction objectHasKeys(obj) {\n  return obj && Object.keys(obj).length > 0;\n}\n\nmodule.exports = objectHasKeys;","'use strict'; // NOTE: this behaves like lodash/defaults, but doesn't mutate the target\n// it also preserve keys order\n\nrequire(\"core-js/modules/es.array.reduce-right.js\");\n\nmodule.exports = function defaultsPure() {\n  var sources = Array.prototype.slice.call(arguments);\n  return sources.reduceRight(function (acc, source) {\n    Object.keys(Object(source)).forEach(function (key) {\n      if (source[key] === undefined) {\n        return;\n      }\n\n      if (acc[key] !== undefined) {\n        // remove if already added, so that we can add it in correct order\n        delete acc[key];\n      }\n\n      acc[key] = source[key];\n    });\n    return acc;\n  }, {});\n};","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nmodule.exports = generateTrees;\n\nvar orderBy = require('../functions/orderBy');\n\nvar find = require('../functions/find');\n\nvar prepareHierarchicalFacetSortBy = require('../functions/formatSort');\n\nfunction generateTrees(state) {\n  return function generate(hierarchicalFacetResult, hierarchicalFacetIndex) {\n    var hierarchicalFacet = state.hierarchicalFacets[hierarchicalFacetIndex];\n    var hierarchicalFacetRefinement = state.hierarchicalFacetsRefinements[hierarchicalFacet.name] && state.hierarchicalFacetsRefinements[hierarchicalFacet.name][0] || '';\n\n    var hierarchicalSeparator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n    var hierarchicalRootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n\n    var hierarchicalShowParentLevel = state._getHierarchicalShowParentLevel(hierarchicalFacet);\n\n    var sortBy = prepareHierarchicalFacetSortBy(state._getHierarchicalFacetSortBy(hierarchicalFacet));\n    var rootExhaustive = hierarchicalFacetResult.every(function (facetResult) {\n      return facetResult.exhaustive;\n    });\n    var generateTreeFn = generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, hierarchicalFacetRefinement);\n    var results = hierarchicalFacetResult;\n\n    if (hierarchicalRootPath) {\n      results = hierarchicalFacetResult.slice(hierarchicalRootPath.split(hierarchicalSeparator).length);\n    }\n\n    return results.reduce(generateTreeFn, {\n      name: state.hierarchicalFacets[hierarchicalFacetIndex].name,\n      count: null,\n      // root level, no count\n      isRefined: true,\n      // root level, always refined\n      path: null,\n      // root level, no path\n      exhaustive: rootExhaustive,\n      data: null\n    });\n  };\n}\n\nfunction generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, currentRefinement) {\n  return function generateTree(hierarchicalTree, hierarchicalFacetResult, currentHierarchicalLevel) {\n    var parent = hierarchicalTree;\n\n    if (currentHierarchicalLevel > 0) {\n      var level = 0;\n      parent = hierarchicalTree;\n\n      while (level < currentHierarchicalLevel) {\n        /**\n         * @type {object[]]} hierarchical data\n         */\n        var data = parent && Array.isArray(parent.data) ? parent.data : [];\n        parent = find(data, function (subtree) {\n          return subtree.isRefined;\n        });\n        level++;\n      }\n    } // we found a refined parent, let's add current level data under it\n\n\n    if (parent) {\n      // filter values in case an object has multiple categories:\n      //   {\n      //     categories: {\n      //       level0: ['beers', 'bières'],\n      //       level1: ['beers > IPA', 'bières > Belges']\n      //     }\n      //   }\n      //\n      // If parent refinement is `beers`, then we do not want to have `bières > Belges`\n      // showing up\n      var picked = Object.keys(hierarchicalFacetResult.data).map(function (facetValue) {\n        return [facetValue, hierarchicalFacetResult.data[facetValue]];\n      }).filter(function (tuple) {\n        var facetValue = tuple[0];\n        return onlyMatchingTree(facetValue, parent.path || hierarchicalRootPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel);\n      });\n      parent.data = orderBy(picked.map(function (tuple) {\n        var facetValue = tuple[0];\n        var facetCount = tuple[1];\n        return format(facetCount, facetValue, hierarchicalSeparator, currentRefinement, hierarchicalFacetResult.exhaustive);\n      }), sortBy[0], sortBy[1]);\n    }\n\n    return hierarchicalTree;\n  };\n}\n\nfunction onlyMatchingTree(facetValue, parentPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel) {\n  // we want the facetValue is a child of hierarchicalRootPath\n  if (hierarchicalRootPath && (facetValue.indexOf(hierarchicalRootPath) !== 0 || hierarchicalRootPath === facetValue)) {\n    return false;\n  } // we always want root levels (only when there is no prefix path)\n\n\n  return !hierarchicalRootPath && facetValue.indexOf(hierarchicalSeparator) === -1 || // if there is a rootPath, being root level mean 1 level under rootPath\n  hierarchicalRootPath && facetValue.split(hierarchicalSeparator).length - hierarchicalRootPath.split(hierarchicalSeparator).length === 1 || // if current refinement is a root level and current facetValue is a root level,\n  // keep the facetValue\n  facetValue.indexOf(hierarchicalSeparator) === -1 && currentRefinement.indexOf(hierarchicalSeparator) === -1 || // currentRefinement is a child of the facet value\n  currentRefinement.indexOf(facetValue) === 0 || // facetValue is a child of the current parent, add it\n  facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 && (hierarchicalShowParentLevel || facetValue.indexOf(currentRefinement) === 0);\n}\n\nfunction format(facetCount, facetValue, hierarchicalSeparator, currentRefinement, exhaustive) {\n  var parts = facetValue.split(hierarchicalSeparator);\n  return {\n    name: parts[parts.length - 1].trim(),\n    path: facetValue,\n    count: facetCount,\n    isRefined: currentRefinement === facetValue || currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,\n    exhaustive: exhaustive,\n    data: null\n  };\n}","'use strict';\n\nfunction valToNumber(v) {\n  if (typeof v === 'number') {\n    return v;\n  } else if (typeof v === 'string') {\n    return parseFloat(v);\n  } else if (Array.isArray(v)) {\n    return v.map(valToNumber);\n  }\n\n  throw new Error('The value should be a number, a parsable string or an array of those.');\n}\n\nmodule.exports = valToNumber;","'use strict'; // @MAJOR can be replaced by native Array#findIndex when we change support\n\nmodule.exports = function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return -1;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return i;\n    }\n  }\n\n  return -1;\n};","'use strict'; // https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source === null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key;\n  var i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nmodule.exports = _objectWithoutPropertiesLoose;","import \"core-js/modules/es.array.reduce.js\";\nimport PropTypes from 'prop-types';\nimport withSideEffect from 'react-side-effect';\nimport isEqual from 'react-fast-compare';\nimport React from 'react';\nimport objectAssign from 'object-assign';\nvar ATTRIBUTE_NAMES = {\n  BODY: \"bodyAttributes\",\n  HTML: \"htmlAttributes\",\n  TITLE: \"titleAttributes\"\n};\nvar TAG_NAMES = {\n  BASE: \"base\",\n  BODY: \"body\",\n  HEAD: \"head\",\n  HTML: \"html\",\n  LINK: \"link\",\n  META: \"meta\",\n  NOSCRIPT: \"noscript\",\n  SCRIPT: \"script\",\n  STYLE: \"style\",\n  TITLE: \"title\"\n};\nvar VALID_TAG_NAMES = Object.keys(TAG_NAMES).map(function (name) {\n  return TAG_NAMES[name];\n});\nvar TAG_PROPERTIES = {\n  CHARSET: \"charset\",\n  CSS_TEXT: \"cssText\",\n  HREF: \"href\",\n  HTTPEQUIV: \"http-equiv\",\n  INNER_HTML: \"innerHTML\",\n  ITEM_PROP: \"itemprop\",\n  NAME: \"name\",\n  PROPERTY: \"property\",\n  REL: \"rel\",\n  SRC: \"src\",\n  TARGET: \"target\"\n};\nvar REACT_TAG_MAP = {\n  accesskey: \"accessKey\",\n  charset: \"charSet\",\n  class: \"className\",\n  contenteditable: \"contentEditable\",\n  contextmenu: \"contextMenu\",\n  \"http-equiv\": \"httpEquiv\",\n  itemprop: \"itemProp\",\n  tabindex: \"tabIndex\"\n};\nvar HELMET_PROPS = {\n  DEFAULT_TITLE: \"defaultTitle\",\n  DEFER: \"defer\",\n  ENCODE_SPECIAL_CHARACTERS: \"encodeSpecialCharacters\",\n  ON_CHANGE_CLIENT_STATE: \"onChangeClientState\",\n  TITLE_TEMPLATE: \"titleTemplate\"\n};\nvar HTML_TAG_MAP = Object.keys(REACT_TAG_MAP).reduce(function (obj, key) {\n  obj[REACT_TAG_MAP[key]] = key;\n  return obj;\n}, {});\nvar SELF_CLOSING_TAGS = [TAG_NAMES.NOSCRIPT, TAG_NAMES.SCRIPT, TAG_NAMES.STYLE];\nvar HELMET_ATTRIBUTE = \"data-react-helmet\";\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar classCallCheck = function classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar inherits = function inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar objectWithoutProperties = function objectWithoutProperties(obj, keys) {\n  var target = {};\n\n  for (var i in obj) {\n    if (keys.indexOf(i) >= 0) continue;\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;\n    target[i] = obj[i];\n  }\n\n  return target;\n};\n\nvar possibleConstructorReturn = function possibleConstructorReturn(self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\n\nvar encodeSpecialCharacters = function encodeSpecialCharacters(str) {\n  var encode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n  if (encode === false) {\n    return String(str);\n  }\n\n  return String(str).replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\").replace(/\"/g, \"&quot;\").replace(/'/g, \"&#x27;\");\n};\n\nvar getTitleFromPropsList = function getTitleFromPropsList(propsList) {\n  var innermostTitle = getInnermostProperty(propsList, TAG_NAMES.TITLE);\n  var innermostTemplate = getInnermostProperty(propsList, HELMET_PROPS.TITLE_TEMPLATE);\n\n  if (innermostTemplate && innermostTitle) {\n    // use function arg to avoid need to escape $ characters\n    return innermostTemplate.replace(/%s/g, function () {\n      return Array.isArray(innermostTitle) ? innermostTitle.join(\"\") : innermostTitle;\n    });\n  }\n\n  var innermostDefaultTitle = getInnermostProperty(propsList, HELMET_PROPS.DEFAULT_TITLE);\n  return innermostTitle || innermostDefaultTitle || undefined;\n};\n\nvar getOnChangeClientState = function getOnChangeClientState(propsList) {\n  return getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || function () {};\n};\n\nvar getAttributesFromPropsList = function getAttributesFromPropsList(tagType, propsList) {\n  return propsList.filter(function (props) {\n    return typeof props[tagType] !== \"undefined\";\n  }).map(function (props) {\n    return props[tagType];\n  }).reduce(function (tagAttrs, current) {\n    return _extends({}, tagAttrs, current);\n  }, {});\n};\n\nvar getBaseTagFromPropsList = function getBaseTagFromPropsList(primaryAttributes, propsList) {\n  return propsList.filter(function (props) {\n    return typeof props[TAG_NAMES.BASE] !== \"undefined\";\n  }).map(function (props) {\n    return props[TAG_NAMES.BASE];\n  }).reverse().reduce(function (innermostBaseTag, tag) {\n    if (!innermostBaseTag.length) {\n      var keys = Object.keys(tag);\n\n      for (var i = 0; i < keys.length; i++) {\n        var attributeKey = keys[i];\n        var lowerCaseAttributeKey = attributeKey.toLowerCase();\n\n        if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && tag[lowerCaseAttributeKey]) {\n          return innermostBaseTag.concat(tag);\n        }\n      }\n    }\n\n    return innermostBaseTag;\n  }, []);\n};\n\nvar getTagsFromPropsList = function getTagsFromPropsList(tagName, primaryAttributes, propsList) {\n  // Calculate list of tags, giving priority innermost component (end of the propslist)\n  var approvedSeenTags = {};\n  return propsList.filter(function (props) {\n    if (Array.isArray(props[tagName])) {\n      return true;\n    }\n\n    if (typeof props[tagName] !== \"undefined\") {\n      warn(\"Helmet: \" + tagName + \" should be of type \\\"Array\\\". Instead found type \\\"\" + _typeof(props[tagName]) + \"\\\"\");\n    }\n\n    return false;\n  }).map(function (props) {\n    return props[tagName];\n  }).reverse().reduce(function (approvedTags, instanceTags) {\n    var instanceSeenTags = {};\n    instanceTags.filter(function (tag) {\n      var primaryAttributeKey = void 0;\n      var keys = Object.keys(tag);\n\n      for (var i = 0; i < keys.length; i++) {\n        var attributeKey = keys[i];\n        var lowerCaseAttributeKey = attributeKey.toLowerCase(); // Special rule with link tags, since rel and href are both primary tags, rel takes priority\n\n        if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === TAG_PROPERTIES.REL && tag[primaryAttributeKey].toLowerCase() === \"canonical\") && !(lowerCaseAttributeKey === TAG_PROPERTIES.REL && tag[lowerCaseAttributeKey].toLowerCase() === \"stylesheet\")) {\n          primaryAttributeKey = lowerCaseAttributeKey;\n        } // Special case for innerHTML which doesn't work lowercased\n\n\n        if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === TAG_PROPERTIES.INNER_HTML || attributeKey === TAG_PROPERTIES.CSS_TEXT || attributeKey === TAG_PROPERTIES.ITEM_PROP)) {\n          primaryAttributeKey = attributeKey;\n        }\n      }\n\n      if (!primaryAttributeKey || !tag[primaryAttributeKey]) {\n        return false;\n      }\n\n      var value = tag[primaryAttributeKey].toLowerCase();\n\n      if (!approvedSeenTags[primaryAttributeKey]) {\n        approvedSeenTags[primaryAttributeKey] = {};\n      }\n\n      if (!instanceSeenTags[primaryAttributeKey]) {\n        instanceSeenTags[primaryAttributeKey] = {};\n      }\n\n      if (!approvedSeenTags[primaryAttributeKey][value]) {\n        instanceSeenTags[primaryAttributeKey][value] = true;\n        return true;\n      }\n\n      return false;\n    }).reverse().forEach(function (tag) {\n      return approvedTags.push(tag);\n    }); // Update seen tags with tags from this instance\n\n    var keys = Object.keys(instanceSeenTags);\n\n    for (var i = 0; i < keys.length; i++) {\n      var attributeKey = keys[i];\n      var tagUnion = objectAssign({}, approvedSeenTags[attributeKey], instanceSeenTags[attributeKey]);\n      approvedSeenTags[attributeKey] = tagUnion;\n    }\n\n    return approvedTags;\n  }, []).reverse();\n};\n\nvar getInnermostProperty = function getInnermostProperty(propsList, property) {\n  for (var i = propsList.length - 1; i >= 0; i--) {\n    var props = propsList[i];\n\n    if (props.hasOwnProperty(property)) {\n      return props[property];\n    }\n  }\n\n  return null;\n};\n\nvar reducePropsToState = function reducePropsToState(propsList) {\n  return {\n    baseTag: getBaseTagFromPropsList([TAG_PROPERTIES.HREF, TAG_PROPERTIES.TARGET], propsList),\n    bodyAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.BODY, propsList),\n    defer: getInnermostProperty(propsList, HELMET_PROPS.DEFER),\n    encode: getInnermostProperty(propsList, HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),\n    htmlAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.HTML, propsList),\n    linkTags: getTagsFromPropsList(TAG_NAMES.LINK, [TAG_PROPERTIES.REL, TAG_PROPERTIES.HREF], propsList),\n    metaTags: getTagsFromPropsList(TAG_NAMES.META, [TAG_PROPERTIES.NAME, TAG_PROPERTIES.CHARSET, TAG_PROPERTIES.HTTPEQUIV, TAG_PROPERTIES.PROPERTY, TAG_PROPERTIES.ITEM_PROP], propsList),\n    noscriptTags: getTagsFromPropsList(TAG_NAMES.NOSCRIPT, [TAG_PROPERTIES.INNER_HTML], propsList),\n    onChangeClientState: getOnChangeClientState(propsList),\n    scriptTags: getTagsFromPropsList(TAG_NAMES.SCRIPT, [TAG_PROPERTIES.SRC, TAG_PROPERTIES.INNER_HTML], propsList),\n    styleTags: getTagsFromPropsList(TAG_NAMES.STYLE, [TAG_PROPERTIES.CSS_TEXT], propsList),\n    title: getTitleFromPropsList(propsList),\n    titleAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.TITLE, propsList)\n  };\n};\n\nvar rafPolyfill = function () {\n  var clock = Date.now();\n  return function (callback) {\n    var currentTime = Date.now();\n\n    if (currentTime - clock > 16) {\n      clock = currentTime;\n      callback(currentTime);\n    } else {\n      setTimeout(function () {\n        rafPolyfill(callback);\n      }, 0);\n    }\n  };\n}();\n\nvar cafPolyfill = function cafPolyfill(id) {\n  return clearTimeout(id);\n};\n\nvar requestAnimationFrame = typeof window !== \"undefined\" ? window.requestAnimationFrame && window.requestAnimationFrame.bind(window) || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || rafPolyfill : global.requestAnimationFrame || rafPolyfill;\nvar cancelAnimationFrame = typeof window !== \"undefined\" ? window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || cafPolyfill : global.cancelAnimationFrame || cafPolyfill;\n\nvar warn = function warn(msg) {\n  return console && typeof console.warn === \"function\" && console.warn(msg);\n};\n\nvar _helmetCallback = null;\n\nvar handleClientStateChange = function handleClientStateChange(newState) {\n  if (_helmetCallback) {\n    cancelAnimationFrame(_helmetCallback);\n  }\n\n  if (newState.defer) {\n    _helmetCallback = requestAnimationFrame(function () {\n      commitTagChanges(newState, function () {\n        _helmetCallback = null;\n      });\n    });\n  } else {\n    commitTagChanges(newState);\n    _helmetCallback = null;\n  }\n};\n\nvar commitTagChanges = function commitTagChanges(newState, cb) {\n  var baseTag = newState.baseTag,\n      bodyAttributes = newState.bodyAttributes,\n      htmlAttributes = newState.htmlAttributes,\n      linkTags = newState.linkTags,\n      metaTags = newState.metaTags,\n      noscriptTags = newState.noscriptTags,\n      onChangeClientState = newState.onChangeClientState,\n      scriptTags = newState.scriptTags,\n      styleTags = newState.styleTags,\n      title = newState.title,\n      titleAttributes = newState.titleAttributes;\n  updateAttributes(TAG_NAMES.BODY, bodyAttributes);\n  updateAttributes(TAG_NAMES.HTML, htmlAttributes);\n  updateTitle(title, titleAttributes);\n  var tagUpdates = {\n    baseTag: updateTags(TAG_NAMES.BASE, baseTag),\n    linkTags: updateTags(TAG_NAMES.LINK, linkTags),\n    metaTags: updateTags(TAG_NAMES.META, metaTags),\n    noscriptTags: updateTags(TAG_NAMES.NOSCRIPT, noscriptTags),\n    scriptTags: updateTags(TAG_NAMES.SCRIPT, scriptTags),\n    styleTags: updateTags(TAG_NAMES.STYLE, styleTags)\n  };\n  var addedTags = {};\n  var removedTags = {};\n  Object.keys(tagUpdates).forEach(function (tagType) {\n    var _tagUpdates$tagType = tagUpdates[tagType],\n        newTags = _tagUpdates$tagType.newTags,\n        oldTags = _tagUpdates$tagType.oldTags;\n\n    if (newTags.length) {\n      addedTags[tagType] = newTags;\n    }\n\n    if (oldTags.length) {\n      removedTags[tagType] = tagUpdates[tagType].oldTags;\n    }\n  });\n  cb && cb();\n  onChangeClientState(newState, addedTags, removedTags);\n};\n\nvar flattenArray = function flattenArray(possibleArray) {\n  return Array.isArray(possibleArray) ? possibleArray.join(\"\") : possibleArray;\n};\n\nvar updateTitle = function updateTitle(title, attributes) {\n  if (typeof title !== \"undefined\" && document.title !== title) {\n    document.title = flattenArray(title);\n  }\n\n  updateAttributes(TAG_NAMES.TITLE, attributes);\n};\n\nvar updateAttributes = function updateAttributes(tagName, attributes) {\n  var elementTag = document.getElementsByTagName(tagName)[0];\n\n  if (!elementTag) {\n    return;\n  }\n\n  var helmetAttributeString = elementTag.getAttribute(HELMET_ATTRIBUTE);\n  var helmetAttributes = helmetAttributeString ? helmetAttributeString.split(\",\") : [];\n  var attributesToRemove = [].concat(helmetAttributes);\n  var attributeKeys = Object.keys(attributes);\n\n  for (var i = 0; i < attributeKeys.length; i++) {\n    var attribute = attributeKeys[i];\n    var value = attributes[attribute] || \"\";\n\n    if (elementTag.getAttribute(attribute) !== value) {\n      elementTag.setAttribute(attribute, value);\n    }\n\n    if (helmetAttributes.indexOf(attribute) === -1) {\n      helmetAttributes.push(attribute);\n    }\n\n    var indexToSave = attributesToRemove.indexOf(attribute);\n\n    if (indexToSave !== -1) {\n      attributesToRemove.splice(indexToSave, 1);\n    }\n  }\n\n  for (var _i = attributesToRemove.length - 1; _i >= 0; _i--) {\n    elementTag.removeAttribute(attributesToRemove[_i]);\n  }\n\n  if (helmetAttributes.length === attributesToRemove.length) {\n    elementTag.removeAttribute(HELMET_ATTRIBUTE);\n  } else if (elementTag.getAttribute(HELMET_ATTRIBUTE) !== attributeKeys.join(\",\")) {\n    elementTag.setAttribute(HELMET_ATTRIBUTE, attributeKeys.join(\",\"));\n  }\n};\n\nvar updateTags = function updateTags(type, tags) {\n  var headElement = document.head || document.querySelector(TAG_NAMES.HEAD);\n  var tagNodes = headElement.querySelectorAll(type + \"[\" + HELMET_ATTRIBUTE + \"]\");\n  var oldTags = Array.prototype.slice.call(tagNodes);\n  var newTags = [];\n  var indexToDelete = void 0;\n\n  if (tags && tags.length) {\n    tags.forEach(function (tag) {\n      var newElement = document.createElement(type);\n\n      for (var attribute in tag) {\n        if (tag.hasOwnProperty(attribute)) {\n          if (attribute === TAG_PROPERTIES.INNER_HTML) {\n            newElement.innerHTML = tag.innerHTML;\n          } else if (attribute === TAG_PROPERTIES.CSS_TEXT) {\n            if (newElement.styleSheet) {\n              newElement.styleSheet.cssText = tag.cssText;\n            } else {\n              newElement.appendChild(document.createTextNode(tag.cssText));\n            }\n          } else {\n            var value = typeof tag[attribute] === \"undefined\" ? \"\" : tag[attribute];\n            newElement.setAttribute(attribute, value);\n          }\n        }\n      }\n\n      newElement.setAttribute(HELMET_ATTRIBUTE, \"true\"); // Remove a duplicate tag from domTagstoRemove, so it isn't cleared.\n\n      if (oldTags.some(function (existingTag, index) {\n        indexToDelete = index;\n        return newElement.isEqualNode(existingTag);\n      })) {\n        oldTags.splice(indexToDelete, 1);\n      } else {\n        newTags.push(newElement);\n      }\n    });\n  }\n\n  oldTags.forEach(function (tag) {\n    return tag.parentNode.removeChild(tag);\n  });\n  newTags.forEach(function (tag) {\n    return headElement.appendChild(tag);\n  });\n  return {\n    oldTags: oldTags,\n    newTags: newTags\n  };\n};\n\nvar generateElementAttributesAsString = function generateElementAttributesAsString(attributes) {\n  return Object.keys(attributes).reduce(function (str, key) {\n    var attr = typeof attributes[key] !== \"undefined\" ? key + \"=\\\"\" + attributes[key] + \"\\\"\" : \"\" + key;\n    return str ? str + \" \" + attr : attr;\n  }, \"\");\n};\n\nvar generateTitleAsString = function generateTitleAsString(type, title, attributes, encode) {\n  var attributeString = generateElementAttributesAsString(attributes);\n  var flattenedTitle = flattenArray(title);\n  return attributeString ? \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\" \" + attributeString + \">\" + encodeSpecialCharacters(flattenedTitle, encode) + \"</\" + type + \">\" : \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\">\" + encodeSpecialCharacters(flattenedTitle, encode) + \"</\" + type + \">\";\n};\n\nvar generateTagsAsString = function generateTagsAsString(type, tags, encode) {\n  return tags.reduce(function (str, tag) {\n    var attributeHtml = Object.keys(tag).filter(function (attribute) {\n      return !(attribute === TAG_PROPERTIES.INNER_HTML || attribute === TAG_PROPERTIES.CSS_TEXT);\n    }).reduce(function (string, attribute) {\n      var attr = typeof tag[attribute] === \"undefined\" ? attribute : attribute + \"=\\\"\" + encodeSpecialCharacters(tag[attribute], encode) + \"\\\"\";\n      return string ? string + \" \" + attr : attr;\n    }, \"\");\n    var tagContent = tag.innerHTML || tag.cssText || \"\";\n    var isSelfClosing = SELF_CLOSING_TAGS.indexOf(type) === -1;\n    return str + \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\" \" + attributeHtml + (isSelfClosing ? \"/>\" : \">\" + tagContent + \"</\" + type + \">\");\n  }, \"\");\n};\n\nvar convertElementAttributestoReactProps = function convertElementAttributestoReactProps(attributes) {\n  var initProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return Object.keys(attributes).reduce(function (obj, key) {\n    obj[REACT_TAG_MAP[key] || key] = attributes[key];\n    return obj;\n  }, initProps);\n};\n\nvar convertReactPropstoHtmlAttributes = function convertReactPropstoHtmlAttributes(props) {\n  var initAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return Object.keys(props).reduce(function (obj, key) {\n    obj[HTML_TAG_MAP[key] || key] = props[key];\n    return obj;\n  }, initAttributes);\n};\n\nvar generateTitleAsReactComponent = function generateTitleAsReactComponent(type, title, attributes) {\n  var _initProps; // assigning into an array to define toString function on it\n\n\n  var initProps = (_initProps = {\n    key: title\n  }, _initProps[HELMET_ATTRIBUTE] = true, _initProps);\n  var props = convertElementAttributestoReactProps(attributes, initProps);\n  return [React.createElement(TAG_NAMES.TITLE, props, title)];\n};\n\nvar generateTagsAsReactComponent = function generateTagsAsReactComponent(type, tags) {\n  return tags.map(function (tag, i) {\n    var _mappedTag;\n\n    var mappedTag = (_mappedTag = {\n      key: i\n    }, _mappedTag[HELMET_ATTRIBUTE] = true, _mappedTag);\n    Object.keys(tag).forEach(function (attribute) {\n      var mappedAttribute = REACT_TAG_MAP[attribute] || attribute;\n\n      if (mappedAttribute === TAG_PROPERTIES.INNER_HTML || mappedAttribute === TAG_PROPERTIES.CSS_TEXT) {\n        var content = tag.innerHTML || tag.cssText;\n        mappedTag.dangerouslySetInnerHTML = {\n          __html: content\n        };\n      } else {\n        mappedTag[mappedAttribute] = tag[attribute];\n      }\n    });\n    return React.createElement(type, mappedTag);\n  });\n};\n\nvar getMethodsForTag = function getMethodsForTag(type, tags, encode) {\n  switch (type) {\n    case TAG_NAMES.TITLE:\n      return {\n        toComponent: function toComponent() {\n          return generateTitleAsReactComponent(type, tags.title, tags.titleAttributes, encode);\n        },\n        toString: function toString() {\n          return generateTitleAsString(type, tags.title, tags.titleAttributes, encode);\n        }\n      };\n\n    case ATTRIBUTE_NAMES.BODY:\n    case ATTRIBUTE_NAMES.HTML:\n      return {\n        toComponent: function toComponent() {\n          return convertElementAttributestoReactProps(tags);\n        },\n        toString: function toString() {\n          return generateElementAttributesAsString(tags);\n        }\n      };\n\n    default:\n      return {\n        toComponent: function toComponent() {\n          return generateTagsAsReactComponent(type, tags);\n        },\n        toString: function toString() {\n          return generateTagsAsString(type, tags, encode);\n        }\n      };\n  }\n};\n\nvar mapStateOnServer = function mapStateOnServer(_ref) {\n  var baseTag = _ref.baseTag,\n      bodyAttributes = _ref.bodyAttributes,\n      encode = _ref.encode,\n      htmlAttributes = _ref.htmlAttributes,\n      linkTags = _ref.linkTags,\n      metaTags = _ref.metaTags,\n      noscriptTags = _ref.noscriptTags,\n      scriptTags = _ref.scriptTags,\n      styleTags = _ref.styleTags,\n      _ref$title = _ref.title,\n      title = _ref$title === undefined ? \"\" : _ref$title,\n      titleAttributes = _ref.titleAttributes;\n  return {\n    base: getMethodsForTag(TAG_NAMES.BASE, baseTag, encode),\n    bodyAttributes: getMethodsForTag(ATTRIBUTE_NAMES.BODY, bodyAttributes, encode),\n    htmlAttributes: getMethodsForTag(ATTRIBUTE_NAMES.HTML, htmlAttributes, encode),\n    link: getMethodsForTag(TAG_NAMES.LINK, linkTags, encode),\n    meta: getMethodsForTag(TAG_NAMES.META, metaTags, encode),\n    noscript: getMethodsForTag(TAG_NAMES.NOSCRIPT, noscriptTags, encode),\n    script: getMethodsForTag(TAG_NAMES.SCRIPT, scriptTags, encode),\n    style: getMethodsForTag(TAG_NAMES.STYLE, styleTags, encode),\n    title: getMethodsForTag(TAG_NAMES.TITLE, {\n      title: title,\n      titleAttributes: titleAttributes\n    }, encode)\n  };\n};\n\nvar Helmet = function Helmet(Component) {\n  var _class, _temp;\n\n  return _temp = _class = function (_React$Component) {\n    inherits(HelmetWrapper, _React$Component);\n\n    function HelmetWrapper() {\n      classCallCheck(this, HelmetWrapper);\n      return possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n    }\n\n    HelmetWrapper.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n      return !isEqual(this.props, nextProps);\n    };\n\n    HelmetWrapper.prototype.mapNestedChildrenToProps = function mapNestedChildrenToProps(child, nestedChildren) {\n      if (!nestedChildren) {\n        return null;\n      }\n\n      switch (child.type) {\n        case TAG_NAMES.SCRIPT:\n        case TAG_NAMES.NOSCRIPT:\n          return {\n            innerHTML: nestedChildren\n          };\n\n        case TAG_NAMES.STYLE:\n          return {\n            cssText: nestedChildren\n          };\n      }\n\n      throw new Error(\"<\" + child.type + \" /> elements are self-closing and can not contain children. Refer to our API for more information.\");\n    };\n\n    HelmetWrapper.prototype.flattenArrayTypeChildren = function flattenArrayTypeChildren(_ref) {\n      var _babelHelpers$extends;\n\n      var child = _ref.child,\n          arrayTypeChildren = _ref.arrayTypeChildren,\n          newChildProps = _ref.newChildProps,\n          nestedChildren = _ref.nestedChildren;\n      return _extends({}, arrayTypeChildren, (_babelHelpers$extends = {}, _babelHelpers$extends[child.type] = [].concat(arrayTypeChildren[child.type] || [], [_extends({}, newChildProps, this.mapNestedChildrenToProps(child, nestedChildren))]), _babelHelpers$extends));\n    };\n\n    HelmetWrapper.prototype.mapObjectTypeChildren = function mapObjectTypeChildren(_ref2) {\n      var _babelHelpers$extends2, _babelHelpers$extends3;\n\n      var child = _ref2.child,\n          newProps = _ref2.newProps,\n          newChildProps = _ref2.newChildProps,\n          nestedChildren = _ref2.nestedChildren;\n\n      switch (child.type) {\n        case TAG_NAMES.TITLE:\n          return _extends({}, newProps, (_babelHelpers$extends2 = {}, _babelHelpers$extends2[child.type] = nestedChildren, _babelHelpers$extends2.titleAttributes = _extends({}, newChildProps), _babelHelpers$extends2));\n\n        case TAG_NAMES.BODY:\n          return _extends({}, newProps, {\n            bodyAttributes: _extends({}, newChildProps)\n          });\n\n        case TAG_NAMES.HTML:\n          return _extends({}, newProps, {\n            htmlAttributes: _extends({}, newChildProps)\n          });\n      }\n\n      return _extends({}, newProps, (_babelHelpers$extends3 = {}, _babelHelpers$extends3[child.type] = _extends({}, newChildProps), _babelHelpers$extends3));\n    };\n\n    HelmetWrapper.prototype.mapArrayTypeChildrenToProps = function mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {\n      var newFlattenedProps = _extends({}, newProps);\n\n      Object.keys(arrayTypeChildren).forEach(function (arrayChildName) {\n        var _babelHelpers$extends4;\n\n        newFlattenedProps = _extends({}, newFlattenedProps, (_babelHelpers$extends4 = {}, _babelHelpers$extends4[arrayChildName] = arrayTypeChildren[arrayChildName], _babelHelpers$extends4));\n      });\n      return newFlattenedProps;\n    };\n\n    HelmetWrapper.prototype.warnOnInvalidChildren = function warnOnInvalidChildren(child, nestedChildren) {\n      if (process.env.NODE_ENV !== \"production\") {\n        if (!VALID_TAG_NAMES.some(function (name) {\n          return child.type === name;\n        })) {\n          if (typeof child.type === \"function\") {\n            return warn(\"You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.\");\n          }\n\n          return warn(\"Only elements types \" + VALID_TAG_NAMES.join(\", \") + \" are allowed. Helmet does not support rendering <\" + child.type + \"> elements. Refer to our API for more information.\");\n        }\n\n        if (nestedChildren && typeof nestedChildren !== \"string\" && (!Array.isArray(nestedChildren) || nestedChildren.some(function (nestedChild) {\n          return typeof nestedChild !== \"string\";\n        }))) {\n          throw new Error(\"Helmet expects a string as a child of <\" + child.type + \">. Did you forget to wrap your children in braces? ( <\" + child.type + \">{``}</\" + child.type + \"> ) Refer to our API for more information.\");\n        }\n      }\n\n      return true;\n    };\n\n    HelmetWrapper.prototype.mapChildrenToProps = function mapChildrenToProps(children, newProps) {\n      var _this2 = this;\n\n      var arrayTypeChildren = {};\n      React.Children.forEach(children, function (child) {\n        if (!child || !child.props) {\n          return;\n        }\n\n        var _child$props = child.props,\n            nestedChildren = _child$props.children,\n            childProps = objectWithoutProperties(_child$props, [\"children\"]);\n        var newChildProps = convertReactPropstoHtmlAttributes(childProps);\n\n        _this2.warnOnInvalidChildren(child, nestedChildren);\n\n        switch (child.type) {\n          case TAG_NAMES.LINK:\n          case TAG_NAMES.META:\n          case TAG_NAMES.NOSCRIPT:\n          case TAG_NAMES.SCRIPT:\n          case TAG_NAMES.STYLE:\n            arrayTypeChildren = _this2.flattenArrayTypeChildren({\n              child: child,\n              arrayTypeChildren: arrayTypeChildren,\n              newChildProps: newChildProps,\n              nestedChildren: nestedChildren\n            });\n            break;\n\n          default:\n            newProps = _this2.mapObjectTypeChildren({\n              child: child,\n              newProps: newProps,\n              newChildProps: newChildProps,\n              nestedChildren: nestedChildren\n            });\n            break;\n        }\n      });\n      newProps = this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);\n      return newProps;\n    };\n\n    HelmetWrapper.prototype.render = function render() {\n      var _props = this.props,\n          children = _props.children,\n          props = objectWithoutProperties(_props, [\"children\"]);\n\n      var newProps = _extends({}, props);\n\n      if (children) {\n        newProps = this.mapChildrenToProps(children, newProps);\n      }\n\n      return React.createElement(Component, newProps);\n    };\n\n    createClass(HelmetWrapper, null, [{\n      key: \"canUseDOM\",\n      // Component.peek comes from react-side-effect:\n      // For testing, you may use a static peek() method available on the returned component.\n      // It lets you get the current state without resetting the mounted instance stack.\n      // Don’t use it for anything other than testing.\n\n      /**\n       * @param {Object} base: {\"target\": \"_blank\", \"href\": \"http://mysite.com/\"}\n       * @param {Object} bodyAttributes: {\"className\": \"root\"}\n       * @param {String} defaultTitle: \"Default Title\"\n       * @param {Boolean} defer: true\n       * @param {Boolean} encodeSpecialCharacters: true\n       * @param {Object} htmlAttributes: {\"lang\": \"en\", \"amp\": undefined}\n       * @param {Array} link: [{\"rel\": \"canonical\", \"href\": \"http://mysite.com/example\"}]\n       * @param {Array} meta: [{\"name\": \"description\", \"content\": \"Test description\"}]\n       * @param {Array} noscript: [{\"innerHTML\": \"<img src='http://mysite.com/js/test.js'\"}]\n       * @param {Function} onChangeClientState: \"(newState) => console.log(newState)\"\n       * @param {Array} script: [{\"type\": \"text/javascript\", \"src\": \"http://mysite.com/js/test.js\"}]\n       * @param {Array} style: [{\"type\": \"text/css\", \"cssText\": \"div { display: block; color: blue; }\"}]\n       * @param {String} title: \"Title\"\n       * @param {Object} titleAttributes: {\"itemprop\": \"name\"}\n       * @param {String} titleTemplate: \"MySite.com - %s\"\n       */\n      set: function set$$1(canUseDOM) {\n        Component.canUseDOM = canUseDOM;\n      }\n    }]);\n    return HelmetWrapper;\n  }(React.Component), _class.propTypes = {\n    base: PropTypes.object,\n    bodyAttributes: PropTypes.object,\n    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),\n    defaultTitle: PropTypes.string,\n    defer: PropTypes.bool,\n    encodeSpecialCharacters: PropTypes.bool,\n    htmlAttributes: PropTypes.object,\n    link: PropTypes.arrayOf(PropTypes.object),\n    meta: PropTypes.arrayOf(PropTypes.object),\n    noscript: PropTypes.arrayOf(PropTypes.object),\n    onChangeClientState: PropTypes.func,\n    script: PropTypes.arrayOf(PropTypes.object),\n    style: PropTypes.arrayOf(PropTypes.object),\n    title: PropTypes.string,\n    titleAttributes: PropTypes.object,\n    titleTemplate: PropTypes.string\n  }, _class.defaultProps = {\n    defer: true,\n    encodeSpecialCharacters: true\n  }, _class.peek = Component.peek, _class.rewind = function () {\n    var mappedState = Component.rewind();\n\n    if (!mappedState) {\n      // provide fallback if mappedState is undefined\n      mappedState = mapStateOnServer({\n        baseTag: [],\n        bodyAttributes: {},\n        encodeSpecialCharacters: true,\n        htmlAttributes: {},\n        linkTags: [],\n        metaTags: [],\n        noscriptTags: [],\n        scriptTags: [],\n        styleTags: [],\n        title: \"\",\n        titleAttributes: {}\n      });\n    }\n\n    return mappedState;\n  }, _temp;\n};\n\nvar NullComponent = function NullComponent() {\n  return null;\n};\n\nvar HelmetSideEffects = withSideEffect(reducePropsToState, handleClientStateChange, mapStateOnServer)(NullComponent);\nvar HelmetExport = Helmet(HelmetSideEffects);\nHelmetExport.renderStatic = HelmetExport.rewind;\nexport default HelmetExport;\nexport { HelmetExport as Helmet };","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar merge = require('../functions/merge');\n\nvar defaultsPure = require('../functions/defaultsPure');\n\nvar orderBy = require('../functions/orderBy');\n\nvar compact = require('../functions/compact');\n\nvar find = require('../functions/find');\n\nvar findIndex = require('../functions/findIndex');\n\nvar formatSort = require('../functions/formatSort');\n\nvar generateHierarchicalTree = require('./generate-hierarchical-tree');\n/**\n * @typedef SearchResults.Facet\n * @type {object}\n * @property {string} name name of the attribute in the record\n * @property {object} data the faceting data: value, number of entries\n * @property {object} stats undefined unless facet_stats is retrieved from algolia\n */\n\n/**\n * @typedef SearchResults.HierarchicalFacet\n * @type {object}\n * @property {string} name name of the current value given the hierarchical level, trimmed.\n * If root node, you get the facet name\n * @property {number} count number of objects matching this hierarchical value\n * @property {string} path the current hierarchical value full path\n * @property {boolean} isRefined `true` if the current value was refined, `false` otherwise\n * @property {HierarchicalFacet[]} data sub values for the current level\n */\n\n/**\n * @typedef SearchResults.FacetValue\n * @type {object}\n * @property {string} name the facet value itself\n * @property {number} count times this facet appears in the results\n * @property {boolean} isRefined is the facet currently selected\n * @property {boolean} isExcluded is the facet currently excluded (only for conjunctive facets)\n */\n\n/**\n * @typedef Refinement\n * @type {object}\n * @property {string} type the type of filter used:\n * `numeric`, `facet`, `exclude`, `disjunctive`, `hierarchical`\n * @property {string} attributeName name of the attribute used for filtering\n * @property {string} name the value of the filter\n * @property {number} numericValue the value as a number. Only for numeric filters.\n * @property {string} operator the operator used. Only for numeric filters.\n * @property {number} count the number of computed hits for this filter. Only on facets.\n * @property {boolean} exhaustive if the count is exhaustive\n */\n\n/**\n * @param {string[]} attributes\n */\n\n\nfunction getIndices(attributes) {\n  var indices = {};\n  attributes.forEach(function (val, idx) {\n    indices[val] = idx;\n  });\n  return indices;\n}\n\nfunction assignFacetStats(dest, facetStats, key) {\n  if (facetStats && facetStats[key]) {\n    dest.stats = facetStats[key];\n  }\n}\n/**\n * @typedef {Object} HierarchicalFacet\n * @property {string} name\n * @property {string[]} attributes\n */\n\n/**\n * @param {HierarchicalFacet[]} hierarchicalFacets\n * @param {string} hierarchicalAttributeName\n */\n\n\nfunction findMatchingHierarchicalFacetFromAttributeName(hierarchicalFacets, hierarchicalAttributeName) {\n  return find(hierarchicalFacets, function facetKeyMatchesAttribute(hierarchicalFacet) {\n    var facetNames = hierarchicalFacet.attributes || [];\n    return facetNames.indexOf(hierarchicalAttributeName) > -1;\n  });\n}\n/*eslint-disable */\n\n/**\n * Constructor for SearchResults\n * @class\n * @classdesc SearchResults contains the results of a query to Algolia using the\n * {@link AlgoliaSearchHelper}.\n * @param {SearchParameters} state state that led to the response\n * @param {array.<object>} results the results from algolia client\n * @example <caption>SearchResults of the first query in\n * <a href=\"http://demos.algolia.com/instant-search-demo\">the instant search demo</a></caption>\n{\n   \"hitsPerPage\": 10,\n   \"processingTimeMS\": 2,\n   \"facets\": [\n      {\n         \"name\": \"type\",\n         \"data\": {\n            \"HardGood\": 6627,\n            \"BlackTie\": 550,\n            \"Music\": 665,\n            \"Software\": 131,\n            \"Game\": 456,\n            \"Movie\": 1571\n         },\n         \"exhaustive\": false\n      },\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"Free shipping\": 5507\n         },\n         \"name\": \"shipping\"\n      }\n  ],\n   \"hits\": [\n      {\n         \"thumbnailImage\": \"http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_54x108_s.gif\",\n         \"_highlightResult\": {\n            \"shortDescription\": {\n               \"matchLevel\": \"none\",\n               \"value\": \"Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection\",\n               \"matchedWords\": []\n            },\n            \"category\": {\n               \"matchLevel\": \"none\",\n               \"value\": \"Computer Security Software\",\n               \"matchedWords\": []\n            },\n            \"manufacturer\": {\n               \"matchedWords\": [],\n               \"value\": \"Webroot\",\n               \"matchLevel\": \"none\"\n            },\n            \"name\": {\n               \"value\": \"Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows\",\n               \"matchedWords\": [],\n               \"matchLevel\": \"none\"\n            }\n         },\n         \"image\": \"http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_105x210_sc.jpg\",\n         \"shipping\": \"Free shipping\",\n         \"bestSellingRank\": 4,\n         \"shortDescription\": \"Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection\",\n         \"url\": \"http://www.bestbuy.com/site/webroot-secureanywhere-internet-security-3-devi…d=1219060687969&skuId=1688832&cmp=RMX&ky=2d3GfEmNIzjA0vkzveHdZEBgpPCyMnLTJ\",\n         \"name\": \"Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows\",\n         \"category\": \"Computer Security Software\",\n         \"salePrice_range\": \"1 - 50\",\n         \"objectID\": \"1688832\",\n         \"type\": \"Software\",\n         \"customerReviewCount\": 5980,\n         \"salePrice\": 49.99,\n         \"manufacturer\": \"Webroot\"\n      },\n      ....\n  ],\n   \"nbHits\": 10000,\n   \"disjunctiveFacets\": [\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"5\": 183,\n            \"12\": 112,\n            \"7\": 149,\n            ...\n         },\n         \"name\": \"customerReviewCount\",\n         \"stats\": {\n            \"max\": 7461,\n            \"avg\": 157.939,\n            \"min\": 1\n         }\n      },\n      {\n         \"data\": {\n            \"Printer Ink\": 142,\n            \"Wireless Speakers\": 60,\n            \"Point & Shoot Cameras\": 48,\n            ...\n         },\n         \"name\": \"category\",\n         \"exhaustive\": false\n      },\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"> 5000\": 2,\n            \"1 - 50\": 6524,\n            \"501 - 2000\": 566,\n            \"201 - 500\": 1501,\n            \"101 - 200\": 1360,\n            \"2001 - 5000\": 47\n         },\n         \"name\": \"salePrice_range\"\n      },\n      {\n         \"data\": {\n            \"Dynex™\": 202,\n            \"Insignia™\": 230,\n            \"PNY\": 72,\n            ...\n         },\n         \"name\": \"manufacturer\",\n         \"exhaustive\": false\n      }\n  ],\n   \"query\": \"\",\n   \"nbPages\": 100,\n   \"page\": 0,\n   \"index\": \"bestbuy\"\n}\n **/\n\n/*eslint-enable */\n\n\nfunction SearchResults(state, results) {\n  var mainSubResponse = results[0];\n  this._rawResults = results;\n  var self = this; // https://www.algolia.com/doc/api-reference/api-methods/search/#response\n\n  Object.keys(mainSubResponse).forEach(function (key) {\n    self[key] = mainSubResponse[key];\n  });\n  /**\n   * query used to generate the results\n   * @name query\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * The query as parsed by the engine given all the rules.\n   * @name parsedQuery\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * all the records that match the search parameters. Each record is\n   * augmented with a new attribute `_highlightResult`\n   * which is an object keyed by attribute and with the following properties:\n   *  - `value` : the value of the facet highlighted (html)\n   *  - `matchLevel`: full, partial or none depending on how the query terms match\n   * @name hits\n   * @member {object[]}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * index where the results come from\n   * @name index\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * number of hits per page requested\n   * @name hitsPerPage\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * total number of hits of this query on the index\n   * @name nbHits\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * total number of pages with respect to the number of hits per page and the total number of hits\n   * @name nbPages\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * current page\n   * @name page\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * The position if the position was guessed by IP.\n   * @name aroundLatLng\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"48.8637,2.3615\",\n   */\n\n  /**\n   * The radius computed by Algolia.\n   * @name automaticRadius\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"126792922\",\n   */\n\n  /**\n   * String identifying the server used to serve this request.\n   *\n   * getRankingInfo needs to be set to `true` for this to be returned\n   *\n   * @name serverUsed\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"c7-use-2.algolia.net\",\n   */\n\n  /**\n   * Boolean that indicates if the computation of the counts did time out.\n   * @deprecated\n   * @name timeoutCounts\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * Boolean that indicates if the computation of the hits did time out.\n   * @deprecated\n   * @name timeoutHits\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * True if the counts of the facets is exhaustive\n   * @name exhaustiveFacetsCount\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * True if the number of hits is exhaustive\n   * @name exhaustiveNbHits\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * Contains the userData if they are set by a [query rule](https://www.algolia.com/doc/guides/query-rules/query-rules-overview/).\n   * @name userData\n   * @member {object[]}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * queryID is the unique identifier of the query used to generate the current search results.\n   * This value is only available if the `clickAnalytics` search parameter is set to `true`.\n   * @name queryID\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * sum of the processing time of all the queries\n   * @member {number}\n   */\n\n  this.processingTimeMS = results.reduce(function (sum, result) {\n    return result.processingTimeMS === undefined ? sum : sum + result.processingTimeMS;\n  }, 0);\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.Facet[]}\n   */\n\n  this.disjunctiveFacets = [];\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.HierarchicalFacet[]}\n   */\n\n  this.hierarchicalFacets = state.hierarchicalFacets.map(function initFutureTree() {\n    return [];\n  });\n  /**\n   * other facets results\n   * @member {SearchResults.Facet[]}\n   */\n\n  this.facets = [];\n  var disjunctiveFacets = state.getRefinedDisjunctiveFacets();\n  var facetsIndices = getIndices(state.facets);\n  var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);\n  var nextDisjunctiveResult = 1; // Since we send request only for disjunctive facets that have been refined,\n  // we get the facets information from the first, general, response.\n\n  var mainFacets = mainSubResponse.facets || {};\n  Object.keys(mainFacets).forEach(function (facetKey) {\n    var facetValueObject = mainFacets[facetKey];\n    var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(state.hierarchicalFacets, facetKey);\n\n    if (hierarchicalFacet) {\n      // Place the hierarchicalFacet data at the correct index depending on\n      // the attributes order that was defined at the helper initialization\n      var facetIndex = hierarchicalFacet.attributes.indexOf(facetKey);\n      var idxAttributeName = findIndex(state.hierarchicalFacets, function (f) {\n        return f.name === hierarchicalFacet.name;\n      });\n      self.hierarchicalFacets[idxAttributeName][facetIndex] = {\n        attribute: facetKey,\n        data: facetValueObject,\n        exhaustive: mainSubResponse.exhaustiveFacetsCount\n      };\n    } else {\n      var isFacetDisjunctive = state.disjunctiveFacets.indexOf(facetKey) !== -1;\n      var isFacetConjunctive = state.facets.indexOf(facetKey) !== -1;\n      var position;\n\n      if (isFacetDisjunctive) {\n        position = disjunctiveFacetsIndices[facetKey];\n        self.disjunctiveFacets[position] = {\n          name: facetKey,\n          data: facetValueObject,\n          exhaustive: mainSubResponse.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.disjunctiveFacets[position], mainSubResponse.facets_stats, facetKey);\n      }\n\n      if (isFacetConjunctive) {\n        position = facetsIndices[facetKey];\n        self.facets[position] = {\n          name: facetKey,\n          data: facetValueObject,\n          exhaustive: mainSubResponse.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.facets[position], mainSubResponse.facets_stats, facetKey);\n      }\n    }\n  }); // Make sure we do not keep holes within the hierarchical facets\n\n  this.hierarchicalFacets = compact(this.hierarchicalFacets); // aggregate the refined disjunctive facets\n\n  disjunctiveFacets.forEach(function (disjunctiveFacet) {\n    var result = results[nextDisjunctiveResult];\n    var facets = result && result.facets ? result.facets : {};\n    var hierarchicalFacet = state.getHierarchicalFacetByName(disjunctiveFacet); // There should be only item in facets.\n\n    Object.keys(facets).forEach(function (dfacet) {\n      var facetResults = facets[dfacet];\n      var position;\n\n      if (hierarchicalFacet) {\n        position = findIndex(state.hierarchicalFacets, function (f) {\n          return f.name === hierarchicalFacet.name;\n        });\n        var attributeIndex = findIndex(self.hierarchicalFacets[position], function (f) {\n          return f.attribute === dfacet;\n        }); // previous refinements and no results so not able to find it\n\n        if (attributeIndex === -1) {\n          return;\n        }\n\n        self.hierarchicalFacets[position][attributeIndex].data = merge({}, self.hierarchicalFacets[position][attributeIndex].data, facetResults);\n      } else {\n        position = disjunctiveFacetsIndices[dfacet];\n        var dataFromMainRequest = mainSubResponse.facets && mainSubResponse.facets[dfacet] || {};\n        self.disjunctiveFacets[position] = {\n          name: dfacet,\n          data: defaultsPure({}, facetResults, dataFromMainRequest),\n          exhaustive: result.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.disjunctiveFacets[position], result.facets_stats, dfacet);\n\n        if (state.disjunctiveFacetsRefinements[dfacet]) {\n          state.disjunctiveFacetsRefinements[dfacet].forEach(function (refinementValue) {\n            // add the disjunctive refinements if it is no more retrieved\n            if (!self.disjunctiveFacets[position].data[refinementValue] && state.disjunctiveFacetsRefinements[dfacet].indexOf(refinementValue) > -1) {\n              self.disjunctiveFacets[position].data[refinementValue] = 0;\n            }\n          });\n        }\n      }\n    });\n    nextDisjunctiveResult++;\n  }); // if we have some root level values for hierarchical facets, merge them\n\n  state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {\n    var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n    var currentRefinement = state.getHierarchicalRefinement(refinedFacet); // if we are already at a root refinement (or no refinement at all), there is no\n    // root level values request\n\n    if (currentRefinement.length === 0 || currentRefinement[0].split(separator).length < 2) {\n      return;\n    }\n\n    var result = results[nextDisjunctiveResult];\n    var facets = result && result.facets ? result.facets : {};\n    Object.keys(facets).forEach(function (dfacet) {\n      var facetResults = facets[dfacet];\n      var position = findIndex(state.hierarchicalFacets, function (f) {\n        return f.name === hierarchicalFacet.name;\n      });\n      var attributeIndex = findIndex(self.hierarchicalFacets[position], function (f) {\n        return f.attribute === dfacet;\n      }); // previous refinements and no results so not able to find it\n\n      if (attributeIndex === -1) {\n        return;\n      } // when we always get root levels, if the hits refinement is `beers > IPA` (count: 5),\n      // then the disjunctive values will be `beers` (count: 100),\n      // but we do not want to display\n      //   | beers (100)\n      //     > IPA (5)\n      // We want\n      //   | beers (5)\n      //     > IPA (5)\n\n\n      var defaultData = {};\n\n      if (currentRefinement.length > 0) {\n        var root = currentRefinement[0].split(separator)[0];\n        defaultData[root] = self.hierarchicalFacets[position][attributeIndex].data[root];\n      }\n\n      self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(defaultData, facetResults, self.hierarchicalFacets[position][attributeIndex].data);\n    });\n    nextDisjunctiveResult++;\n  }); // add the excludes\n\n  Object.keys(state.facetsExcludes).forEach(function (facetName) {\n    var excludes = state.facetsExcludes[facetName];\n    var position = facetsIndices[facetName];\n    self.facets[position] = {\n      name: facetName,\n      data: mainSubResponse.facets[facetName],\n      exhaustive: mainSubResponse.exhaustiveFacetsCount\n    };\n    excludes.forEach(function (facetValue) {\n      self.facets[position] = self.facets[position] || {\n        name: facetName\n      };\n      self.facets[position].data = self.facets[position].data || {};\n      self.facets[position].data[facetValue] = 0;\n    });\n  });\n  /**\n   * @type {Array}\n   */\n\n  this.hierarchicalFacets = this.hierarchicalFacets.map(generateHierarchicalTree(state));\n  /**\n   * @type {Array}\n   */\n\n  this.facets = compact(this.facets);\n  /**\n   * @type {Array}\n   */\n\n  this.disjunctiveFacets = compact(this.disjunctiveFacets);\n  this._state = state;\n}\n/**\n * Get a facet object with its name\n * @deprecated\n * @param {string} name name of the faceted attribute\n * @return {SearchResults.Facet} the facet object\n */\n\n\nSearchResults.prototype.getFacetByName = function (name) {\n  function predicate(facet) {\n    return facet.name === name;\n  }\n\n  return find(this.facets, predicate) || find(this.disjunctiveFacets, predicate) || find(this.hierarchicalFacets, predicate);\n};\n/**\n * Get the facet values of a specified attribute from a SearchResults object.\n * @private\n * @param {SearchResults} results the search results to search in\n * @param {string} attribute name of the faceted attribute to search for\n * @return {array|object} facet values. For the hierarchical facets it is an object.\n */\n\n\nfunction extractNormalizedFacetValues(results, attribute) {\n  function predicate(facet) {\n    return facet.name === attribute;\n  }\n\n  if (results._state.isConjunctiveFacet(attribute)) {\n    var facet = find(results.facets, predicate);\n    if (!facet) return [];\n    return Object.keys(facet.data).map(function (name) {\n      return {\n        name: name,\n        count: facet.data[name],\n        isRefined: results._state.isFacetRefined(attribute, name),\n        isExcluded: results._state.isExcludeRefined(attribute, name)\n      };\n    });\n  } else if (results._state.isDisjunctiveFacet(attribute)) {\n    var disjunctiveFacet = find(results.disjunctiveFacets, predicate);\n    if (!disjunctiveFacet) return [];\n    return Object.keys(disjunctiveFacet.data).map(function (name) {\n      return {\n        name: name,\n        count: disjunctiveFacet.data[name],\n        isRefined: results._state.isDisjunctiveFacetRefined(attribute, name)\n      };\n    });\n  } else if (results._state.isHierarchicalFacet(attribute)) {\n    return find(results.hierarchicalFacets, predicate);\n  }\n}\n/**\n * Sort nodes of a hierarchical facet results\n * @private\n * @param {HierarchicalFacet} node node to upon which we want to apply the sort\n */\n\n\nfunction recSort(sortFn, node) {\n  if (!node.data || node.data.length === 0) {\n    return node;\n  }\n\n  var children = node.data.map(function (childNode) {\n    return recSort(sortFn, childNode);\n  });\n  var sortedChildren = sortFn(children);\n  var newNode = merge({}, node, {\n    data: sortedChildren\n  });\n  return newNode;\n}\n\nSearchResults.DEFAULT_SORT = ['isRefined:desc', 'count:desc', 'name:asc'];\n\nfunction vanillaSortFn(order, data) {\n  return data.sort(order);\n}\n/**\n * Get a the list of values for a given facet attribute. Those values are sorted\n * refinement first, descending count (bigger value on top), and name ascending\n * (alphabetical order). The sort formula can overridden using either string based\n * predicates or a function.\n *\n * This method will return all the values returned by the Algolia engine plus all\n * the values already refined. This means that it can happen that the\n * `maxValuesPerFacet` [configuration](https://www.algolia.com/doc/rest-api/search#param-maxValuesPerFacet)\n * might not be respected if you have facet values that are already refined.\n * @param {string} attribute attribute name\n * @param {object} opts configuration options.\n * @param {Array.<string> | function} opts.sortBy\n * When using strings, it consists of\n * the name of the [FacetValue](#SearchResults.FacetValue) or the\n * [HierarchicalFacet](#SearchResults.HierarchicalFacet) attributes with the\n * order (`asc` or `desc`). For example to order the value by count, the\n * argument would be `['count:asc']`.\n *\n * If only the attribute name is specified, the ordering defaults to the one\n * specified in the default value for this attribute.\n *\n * When not specified, the order is\n * ascending.  This parameter can also be a function which takes two facet\n * values and should return a number, 0 if equal, 1 if the first argument is\n * bigger or -1 otherwise.\n *\n * The default value for this attribute `['isRefined:desc', 'count:desc', 'name:asc']`\n * @return {FacetValue[]|HierarchicalFacet|undefined} depending on the type of facet of\n * the attribute requested (hierarchical, disjunctive or conjunctive)\n * @example\n * helper.on('result', function(event){\n *   //get values ordered only by name ascending using the string predicate\n *   event.results.getFacetValues('city', {sortBy: ['name:asc']});\n *   //get values  ordered only by count ascending using a function\n *   event.results.getFacetValues('city', {\n *     // this is equivalent to ['count:asc']\n *     sortBy: function(a, b) {\n *       if (a.count === b.count) return 0;\n *       if (a.count > b.count)   return 1;\n *       if (b.count > a.count)   return -1;\n *     }\n *   });\n * });\n */\n\n\nSearchResults.prototype.getFacetValues = function (attribute, opts) {\n  var facetValues = extractNormalizedFacetValues(this, attribute);\n\n  if (!facetValues) {\n    return undefined;\n  }\n\n  var options = defaultsPure({}, opts, {\n    sortBy: SearchResults.DEFAULT_SORT\n  });\n\n  if (Array.isArray(options.sortBy)) {\n    var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);\n\n    if (Array.isArray(facetValues)) {\n      return orderBy(facetValues, order[0], order[1]);\n    } // If facetValues is not an array, it's an object thus a hierarchical facet object\n\n\n    return recSort(function (hierarchicalFacetValues) {\n      return orderBy(hierarchicalFacetValues, order[0], order[1]);\n    }, facetValues);\n  } else if (typeof options.sortBy === 'function') {\n    if (Array.isArray(facetValues)) {\n      return facetValues.sort(options.sortBy);\n    } // If facetValues is not an array, it's an object thus a hierarchical facet object\n\n\n    return recSort(function (data) {\n      return vanillaSortFn(options.sortBy, data);\n    }, facetValues);\n  }\n\n  throw new Error('options.sortBy is optional but if defined it must be ' + 'either an array of string (predicates) or a sorting function');\n};\n/**\n * Returns the facet stats if attribute is defined and the facet contains some.\n * Otherwise returns undefined.\n * @param {string} attribute name of the faceted attribute\n * @return {object} The stats of the facet\n */\n\n\nSearchResults.prototype.getFacetStats = function (attribute) {\n  if (this._state.isConjunctiveFacet(attribute)) {\n    return getFacetStatsIfAvailable(this.facets, attribute);\n  } else if (this._state.isDisjunctiveFacet(attribute)) {\n    return getFacetStatsIfAvailable(this.disjunctiveFacets, attribute);\n  }\n\n  return undefined;\n};\n/**\n * @typedef {Object} FacetListItem\n * @property {string} name\n */\n\n/**\n * @param {FacetListItem[]} facetList (has more items, but enough for here)\n * @param {string} facetName\n */\n\n\nfunction getFacetStatsIfAvailable(facetList, facetName) {\n  var data = find(facetList, function (facet) {\n    return facet.name === facetName;\n  });\n  return data && data.stats;\n}\n/**\n * Returns all refinements for all filters + tags. It also provides\n * additional information: count and exhaustiveness for each filter.\n *\n * See the [refinement type](#Refinement) for an exhaustive view of the available\n * data.\n *\n * Note that for a numeric refinement, results are grouped per operator, this\n * means that it will return responses for operators which are empty.\n *\n * @return {Array.<Refinement>} all the refinements\n */\n\n\nSearchResults.prototype.getRefinements = function () {\n  var state = this._state;\n  var results = this;\n  var res = [];\n  Object.keys(state.facetsRefinements).forEach(function (attributeName) {\n    state.facetsRefinements[attributeName].forEach(function (name) {\n      res.push(getRefinement(state, 'facet', attributeName, name, results.facets));\n    });\n  });\n  Object.keys(state.facetsExcludes).forEach(function (attributeName) {\n    state.facetsExcludes[attributeName].forEach(function (name) {\n      res.push(getRefinement(state, 'exclude', attributeName, name, results.facets));\n    });\n  });\n  Object.keys(state.disjunctiveFacetsRefinements).forEach(function (attributeName) {\n    state.disjunctiveFacetsRefinements[attributeName].forEach(function (name) {\n      res.push(getRefinement(state, 'disjunctive', attributeName, name, results.disjunctiveFacets));\n    });\n  });\n  Object.keys(state.hierarchicalFacetsRefinements).forEach(function (attributeName) {\n    state.hierarchicalFacetsRefinements[attributeName].forEach(function (name) {\n      res.push(getHierarchicalRefinement(state, attributeName, name, results.hierarchicalFacets));\n    });\n  });\n  Object.keys(state.numericRefinements).forEach(function (attributeName) {\n    var operators = state.numericRefinements[attributeName];\n    Object.keys(operators).forEach(function (operator) {\n      operators[operator].forEach(function (value) {\n        res.push({\n          type: 'numeric',\n          attributeName: attributeName,\n          name: value,\n          numericValue: value,\n          operator: operator\n        });\n      });\n    });\n  });\n  state.tagRefinements.forEach(function (name) {\n    res.push({\n      type: 'tag',\n      attributeName: '_tags',\n      name: name\n    });\n  });\n  return res;\n};\n/**\n * @typedef {Object} Facet\n * @property {string} name\n * @property {Object} data\n * @property {boolean} exhaustive\n */\n\n/**\n * @param {*} state\n * @param {*} type\n * @param {string} attributeName\n * @param {*} name\n * @param {Facet[]} resultsFacets\n */\n\n\nfunction getRefinement(state, type, attributeName, name, resultsFacets) {\n  var facet = find(resultsFacets, function (f) {\n    return f.name === attributeName;\n  });\n  var count = facet && facet.data && facet.data[name] ? facet.data[name] : 0;\n  var exhaustive = facet && facet.exhaustive || false;\n  return {\n    type: type,\n    attributeName: attributeName,\n    name: name,\n    count: count,\n    exhaustive: exhaustive\n  };\n}\n/**\n * @param {*} state\n * @param {string} attributeName\n * @param {*} name\n * @param {Facet[]} resultsFacets\n */\n\n\nfunction getHierarchicalRefinement(state, attributeName, name, resultsFacets) {\n  var facetDeclaration = state.getHierarchicalFacetByName(attributeName);\n\n  var separator = state._getHierarchicalFacetSeparator(facetDeclaration);\n\n  var split = name.split(separator);\n  var rootFacet = find(resultsFacets, function (facet) {\n    return facet.name === attributeName;\n  });\n  var facet = split.reduce(function (intermediateFacet, part) {\n    var newFacet = intermediateFacet && find(intermediateFacet.data, function (f) {\n      return f.name === part;\n    });\n    return newFacet !== undefined ? newFacet : intermediateFacet;\n  }, rootFacet);\n  var count = facet && facet.count || 0;\n  var exhaustive = facet && facet.exhaustive || false;\n  var path = facet && facet.path || '';\n  return {\n    type: 'hierarchical',\n    attributeName: attributeName,\n    name: path,\n    count: count,\n    exhaustive: exhaustive\n  };\n}\n\nmodule.exports = SearchResults;","/**\r\n * SEO component that queries for data with\r\n *  Gatsby's useStaticQuery React hook\r\n *\r\n * See: https://www.gatsbyjs.com/docs/use-static-query/\r\n */\r\n\r\nimport React from \"react\"\r\nimport PropTypes from \"prop-types\"\r\nimport { Helmet } from \"react-helmet\"\r\nimport { useStaticQuery, graphql } from \"gatsby\"\r\n\r\nfunction SEO({ description, lang, meta, title }) {\r\n  const { site } = useStaticQuery(\r\n    graphql`\r\n      query {\r\n        site {\r\n          siteMetadata {\r\n            title\r\n            description\r\n            author\r\n          }\r\n        }\r\n      }\r\n    `\r\n  )\r\n\r\n  const metaDescription = description || site.siteMetadata.description\r\n  const defaultTitle = site.siteMetadata?.title\r\n\r\n  return (\r\n    <Helmet\r\n      htmlAttributes={{\r\n        lang,\r\n      }}\r\n      title={title}\r\n      titleTemplate={defaultTitle ? `%s | ${defaultTitle}` : null}\r\n      meta={[\r\n        {\r\n          name: `description`,\r\n          content: metaDescription,\r\n        },\r\n        {\r\n          property: `og:title`,\r\n          content: title,\r\n        },\r\n        {\r\n          property: `og:description`,\r\n          content: metaDescription,\r\n        },\r\n        {\r\n          property: `og:type`,\r\n          content: `website`,\r\n        },\r\n        {\r\n          name: `twitter:card`,\r\n          content: `summary`,\r\n        },\r\n        {\r\n          name: `twitter:creator`,\r\n          content: site.siteMetadata?.author || ``,\r\n        },\r\n        {\r\n          name: `twitter:title`,\r\n          content: title,\r\n        },\r\n        {\r\n          name: `twitter:description`,\r\n          content: metaDescription,\r\n        },\r\n      ].concat(meta)}\r\n    />\r\n  )\r\n}\r\n\r\nSEO.defaultProps = {\r\n  lang: `en`,\r\n  meta: [],\r\n  description: ``,\r\n}\r\n\r\nSEO.propTypes = {\r\n  description: PropTypes.string,\r\n  lang: PropTypes.string,\r\n  meta: PropTypes.arrayOf(PropTypes.object),\r\n  title: PropTypes.string.isRequired,\r\n}\r\n\r\nexport default SEO\r\n","'use strict';\n\nfunction compareAscending(value, other) {\n  if (value !== other) {\n    var valIsDefined = value !== undefined;\n    var valIsNull = value === null;\n    var othIsDefined = other !== undefined;\n    var othIsNull = other === null;\n\n    if (!othIsNull && value > other || valIsNull && othIsDefined || !valIsDefined) {\n      return 1;\n    }\n\n    if (!valIsNull && value < other || othIsNull && valIsDefined || !othIsDefined) {\n      return -1;\n    }\n  }\n\n  return 0;\n}\n/**\n * @param {Array<object>} collection object with keys in attributes\n * @param {Array<string>} iteratees attributes\n * @param {Array<string>} orders asc | desc\n */\n\n\nfunction orderBy(collection, iteratees, orders) {\n  if (!Array.isArray(collection)) {\n    return [];\n  }\n\n  if (!Array.isArray(orders)) {\n    orders = [];\n  }\n\n  var result = collection.map(function (value, index) {\n    return {\n      criteria: iteratees.map(function (iteratee) {\n        return value[iteratee];\n      }),\n      index: index,\n      value: value\n    };\n  });\n  result.sort(function comparer(object, other) {\n    var index = -1;\n\n    while (++index < object.criteria.length) {\n      var res = compareAscending(object.criteria[index], other.criteria[index]);\n\n      if (res) {\n        if (index >= orders.length) {\n          return res;\n        }\n\n        if (orders[index] === 'desc') {\n          return -res;\n        }\n\n        return res;\n      }\n    } // This ensures a stable sort in V8 and other engines.\n    // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n\n\n    return object.index - other.index;\n  });\n  return result.map(function (res) {\n    return res.value;\n  });\n}\n\nmodule.exports = orderBy;","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n"],"sourceRoot":""}