{"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/visualARQ-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","VisualARQLogo","rootCssClasses","viewBox","width","height","className","xmlns","transform","d","fill","fillRule","stroke","strokeWidth","fillOpacity","x","y","fontFamily","fontSize","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","allSearchResults","_ref$preTag","_ref$postTag","highlight","hostname","location","url","queryID","__queryID","addQueryID","__position","getIndexContext","Index","indexContext","inferredIndexId","AlgoliaLogo","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","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-1c6b15440eee4edbbfc5.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\";\nimport PropTypes from \"prop-types\";\n\nconst VisualARQLogo = ({ rootCssClasses }) => (\n  //<svg viewBox=\"0 0 250 44.29\" className={rootCssClasses}>\n<svg viewBox=\"0 0 500 77\" width=\"100%\" height=\"100%\" className={rootCssClasses}  version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n    <style type=\"text/css\">\n        @import url('https://fonts.googleapis.com/css2?family=Ropa+Sans&display=swap');\n    </style>\n    <g transform=\"matrix(1,0,0,1,-65.7616,-170.038)\">\n        <g>\n            <path d=\"M188.77,224.706L188.77,201.561C188.77,201.561 184.933,187.405 172.169,183.255C168.345,182.015 162.669,181.155 154.867,181.629C139.709,182.553 121.702,182.738 117.067,180.054C114.469,178.554 113.263,176.143 112.514,174.411C112.131,173.525 112.145,174.241 112.145,174.241L114.566,197.057C114.566,197.057 117.17,204.058 126.565,205.358C135.969,206.657 161.365,205.43 164.667,205.358C180.143,205.017 186.678,220.381 188.349,224.969C188.59,225.623 188.77,225.185 188.77,224.706Z\" fill=\"rgb(21,118,153)\" fillRule=\"nonzero\" stroke=\"rgb(21,118,153)\" strokeWidth=\"1.03px\"/>\n            <path d=\"M173.948,237.662L173.948,214.01C173.948,214.01 170.113,199.855 157.349,195.704C153.524,194.464 147.846,193.604 140.045,194.078C124.89,195.002 106.883,195.186 102.246,192.504C99.65,191.007 98.444,188.592 97.695,186.858C97.312,185.972 97.323,186.688 97.323,186.688L99.744,209.506C99.744,209.506 102.349,216.511 111.745,217.807C121.148,219.107 146.542,217.879 149.849,217.807C165.322,217.466 171.858,232.828 173.529,237.416C173.768,238.076 173.948,237.662 173.948,237.662Z\" fill=\"rgb(27,148,192)\" fillOpacity=\"0.8\" fillRule=\"nonzero\"/>\n            <path d=\"M173.948,237.357L173.948,214.009C173.948,214.009 170.113,199.856 157.349,195.704C153.524,194.464 147.846,193.605 140.045,194.078C124.89,195.001 106.883,195.186 102.246,192.505C99.65,191.008 98.444,188.593 97.695,186.858C97.312,185.973 97.323,186.688 97.323,186.688L99.744,209.505C99.744,209.505 102.349,216.51 111.745,217.806C121.148,219.108 146.542,217.88 149.849,217.806C165.322,217.466 171.858,232.829 173.529,237.417C173.768,238.076 173.948,237.71 173.948,237.357Z\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M98.14,194.271C98.528,195.166 100.363,200.882 113.472,202.539C120.359,203.408 138.114,201.58 146.07,201.58C154.026,201.58 160.963,203.808 166.25,208.328C171.534,212.85 173.947,220.147 173.947,220.147\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M102.794,213.728L100.15,190.835\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M107.93,216.868L104.965,193.801\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M114.56,218.092L111.802,194.392\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M122.015,218.377L119.639,194.684\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M129.596,218.377L127.859,194.612\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M137.623,218.213L136.179,194.199\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M145.389,217.892L143.812,194.034\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M152.864,217.944L151.882,194.396\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M159.567,219.943L158.82,196.348\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M164.594,223.427L164.23,199.534\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M168.2,227.422L168.07,203.215\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M170.857,231.552L171.044,207.426\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.89px\"/>\n            <path d=\"M155.657,247.991L155.657,224.334C155.657,224.334 151.817,210.181 139.055,206.033C135.233,204.789 129.557,203.93 121.755,204.407C106.596,205.329 89.131,205.186 84.496,202.51C81.897,201.005 80.151,198.918 79.401,197.186C79.019,196.302 79.035,197.015 79.035,197.015L81.455,219.83C81.455,219.83 84.059,226.831 93.456,228.135C102.859,229.433 128.253,228.205 131.555,228.135C147.031,227.795 153.562,243.154 155.237,247.742C155.475,248.397 155.657,247.991 155.657,247.991Z\" fill=\"rgb(77,187,225)\" fillOpacity=\"0.8\" fillRule=\"nonzero\"/>\n            <path d=\"M155.657,247.571L155.657,224.334C155.657,224.334 151.817,210.181 139.055,206.033C135.233,204.789 129.557,203.93 121.755,204.407C106.596,205.329 89.719,205.543 85.084,202.87C82.485,201.365 80.151,198.918 79.401,197.185C79.019,196.302 79.035,197.015 79.035,197.015L81.455,219.83C81.455,219.83 84.059,226.831 93.456,228.135C102.859,229.433 128.253,228.205 131.555,228.135C147.031,227.794 153.562,243.154 155.237,247.742C155.475,248.397 155.657,248.019 155.657,247.571Z\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M80.657,212.286C80.768,213.327 82.804,219.023 92.727,221.079C99.567,222.493 116.567,221.171 125.034,220.983C133.502,220.79 140.305,221.187 146.477,225.833C152.653,230.48 155.071,239.52 155.071,239.52L155.581,240.984\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M79.795,204.194C79.92,205.366 84.153,212.408 94.721,213.022C99.685,213.31 121.011,212.577 130.118,212.577C139.218,212.577 143.357,215.374 147.241,218.369C151.123,221.36 155.07,230.272 155.07,230.272L155.646,231.484\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M84.504,224.062L81.837,200.396\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M89.368,227.092L87.162,203.684\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M96.035,228.419L93.766,204.723\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M103.679,228.702L101.332,205.012\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M111.321,228.702L109.626,204.937\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M119.327,228.541L117.872,204.723\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M127.094,228.213L125.513,204.283\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M134.544,228.267L133.589,204.724\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M141.271,230.272L140.53,206.676\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M146.301,233.742L145.939,209.858\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M149.936,237.746L149.779,213.54\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n            <path d=\"M152.944,242.576L153.13,218.131\" fill=\"none\" fillRule=\"nonzero\" stroke=\"rgb(27,148,192)\" strokeWidth=\"0.45px\"/>\n        </g>\n    </g>\n    <g transform=\"matrix(0.994329,0,0,1,135.237,50.9615)\">\n        <text x=\"0px\" y=\"0px\" fontFamily=\"'RopaSans-Regular', 'Ropa Sans'\" fontSize=\"63.829px\" fill=\"rgb(79,79,79)\">Vis<tspan x=\"72.126px \" y=\"0px \">u</tspan>al</text>\n        <text x=\"145.785px\" y=\"0px\" fontFamily=\"RopaSans-Regular, Ropa Sans\" fontSize=\"63.829px\" fill=\"rgb(27,148,192)\">AR<tspan x=\"213.762px \" y=\"0px \">Q</tspan></text>\n    </g>\n    <g transform=\"matrix(1.126,0,0,1,216.018,71.469)\">\n        <text x=\"0px\" y=\"0px\" fontFamily=\"'RopaSans-Regular', 'Ropa Sans'\" fontSize=\"17.995px\" fillOpacity=\"0.65\">Flexible BIM f<tspan x=\"90.623px \" y=\"0px \">o</tspan>r Rhino</text>\n    </g>\n</svg>\n);\n\nVisualARQLogo.propTypes = {\n  rootCssClasses: PropTypes.string,\n};\n\nVisualARQLogo.defaultProps = {\n  rootCssClasses: \"\",\n};\n\nexport default VisualARQLogo;\n","/* eslint-disable jsx-a11y/no-onchange */\n\nimport React, { useMemo } from \"react\";\nimport { navigate, useStaticQuery, graphql } from \"gatsby\";\n\nimport { useIntl } from \"../contexts/IntlContext\";\n\n/**\n * Creates the list of language options for each translation available.\n * @param {Object} translationsData Keys are the locales and value is the path {<locale>: <path>}\n * @param {Object[]} languagesData Each object has a 'locale' ex: en-us, and 'name' ex: English\n */\nconst createLangOptions = (translationsData, languagesData) => {\n  const options = [];\n  for (const key of Object.keys(translationsData)) {\n    options.push(\n      <option value={key} key={key}>\n        {languagesData.find(l => l.locale === key)?.name ?? key}\n      </option>\n    );\n  }\n  return options;\n};\n\nconst Language = () => {\n  const { lang, storeLang, translations } = useIntl();\n\n  const {\n    allLanguage: { nodes: languages },\n  } = useStaticQuery(graphql`\n    query LanguagesQuery {\n      allLanguage {\n        nodes {\n          locale\n          name\n        }\n      }\n    }\n  `);\n\n  const options = useMemo(() => createLangOptions(translations, languages), [\n    translations,\n  ]);\n\n  return (\n    <>\n      {Object.keys(translations).length > 0 ? (\n        <form className=\"relative\">\n          <label htmlFor=\"lang\" className=\"sr-only\">\n            Language picker\n          </label>\n          <select\n            name=\"lang\"\n            id=\"lang\"\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\"\n            value={lang}\n            onChange={e => {\n              const lang = e.target.value;\n              navigate(translations[lang]);\n              storeLang(lang);\n            }}\n          >\n            {options}\n          </select>\n          <svg\n            className=\"w-5 h-5 text-gray-500 absolute top-1/2 right-0 -mt-2.5 pointer-events-none\"\n            fill=\"currentColor\"\n          >\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\" />\n          </svg>\n        </form>\n      ) : null}\n    </>\n  );\n};\n\nexport default Language;\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\";\nimport { connectSearchBox } from \"react-instantsearch-dom\";\n\nexport default connectSearchBox(\n  ({ refine, currentRefinement, onFocus, hasFocus }) => (\n    <form className=\"flex flex-row-reverse items-center\">\n      <input\n        className={`py-1 pr-6 pl-2 transition-all ${\n          hasFocus ? \"w-64 outline-subtle\" : \"w-32 outline-none cursor-pointer\"\n        }`}\n        type=\"text\"\n        placeholder=\"Search\"\n        aria-label=\"Search\"\n        onChange={e => refine(e.target.value)}\n        value={currentRefinement}\n        onFocus={onFocus}\n      />\n      <svg\n        viewBox=\"0 0 24 24\"\n        height=\"24\"\n        width=\"24\"\n        className=\"absolute w-5 m-1 pointer-events-none\"\n      >\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\" />\n      </svg>\n    </form>\n  )\n);\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\";\n\nconst AlgoliaLogo = ({ className }) => (\n  <svg\n    xmlns=\"http://www.w3.org/2000/svg\"\n    baseProfile=\"basic\"\n    viewBox=\"0 0 1366 362\"\n    width=\"100\"\n    height=\"27\"\n    className={className}\n  >\n    <linearGradient\n      id=\"g\"\n      x1=\"428.258\"\n      x2=\"434.145\"\n      y1=\"404.15\"\n      y2=\"409.85\"\n      gradientUnits=\"userSpaceOnUse\"\n      gradientTransform=\"matrix(94.045 0 0 -94.072 -40381.527 38479.52)\"\n    >\n      <stop offset=\"0\" stopColor=\"#00AEFF\"></stop>\n      <stop offset=\"1\" stopColor=\"#3369E7\"></stop>\n    </linearGradient>\n    <path\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\"\n      fill=\"url(#g)\"\n    ></path>\n    <path\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\"\n      fill=\"#FFFFFF\"\n    ></path>\n    <path\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\"\n      fill=\"#182359\"\n    ></path>\n  </svg>\n);\n\nexport default AlgoliaLogo;\n","import React from \"react\";\nimport { Link } from \"gatsby\";\nimport {\n  connectStateResults,\n  connectHighlight,\n  connectHits,\n  connectPoweredBy,\n  Index,\n  Snippet,\n} from \"react-instantsearch-dom\";\n\nimport AlgoliaLogo from \"./algolia-logo\";\n\nimport { useIntl } from \"../../contexts/IntlContext\";\n\nconst HitCount = connectStateResults(({ searchResults }) => {\n  const hitCount = searchResults && searchResults.nbHits;\n\n  return (\n    <div className=\"flex justify-center mb-3.5\">\n      {hitCount > 0\n        ? `${hitCount} result${hitCount !== 1 ? \"s\" : \"\"}`\n        : \"No results\"}\n    </div>\n  );\n});\n\nconst CustomHighlight = connectHighlight(({ highlight, attribute, hit }) => {\n  const parsedHit = highlight({\n    highlightProperty: \"_highlightResult\",\n    attribute,\n    hit,\n  });\n\n  return (\n    <span>\n      {parsedHit.map((part, index) =>\n        part.isHighlighted ? (\n          <mark key={index} className=\"bg-blue-100\">\n            {part.value}\n          </mark>\n        ) : (\n          <span key={index}>{part.value}</span>\n        )\n      )}\n    </span>\n  );\n});\n\nconst CustomPoweredBy = connectPoweredBy(({ url }) => (\n  <div className=\"flex justify-end items-center mt-3.5 text-xs\">\n    <a\n      href={url}\n      target=\"_blank\"\n      aria-label=\"Algolia\"\n      rel=\"noopener noreferrer\"\n    >\n      <span>Search by</span>\n      <AlgoliaLogo className=\"w-20 ml-1.5\" />\n    </a>\n  </div>\n));\n\nconst CustomHits = connectHits(({ hits, lang }) => (\n  <ul className=\"max-h-60-screen overflow-y-auto\">\n    {hits.map(hit => (\n      <li key={hit.objectID}>\n        {hit[`paths_${lang}`] && hit[`paths_${lang}`].map(path => (\n          <div key={path} className=\"mb-2 p-1 hover:bg-gray-100\">\n            <Link to={path} className=\"block\">\n              <CustomHighlight attribute={`title_${lang}`} hit={hit} />\n            </Link>\n            {/* <Snippet attribute=\"htmlContent\" hit={hit} tagName=\"mark\" /> */}\n          </div>\n        ))}\n      </li>\n    ))}\n  </ul>\n));\n\nconst SearchResult = ({ indices, show }) => {\n  const { lang } = useIntl();\n\n  return (\n    <div\n      className={`mt-2 p-4 absolute right-0 top-full z-10 bg-white shadow-lg max-w-lg w-80-screen ${\n        show ? \"block\" : \"hidden\"\n      }`}\n    >\n      {indices.map(index => (\n        <Index indexName={index.name} key={index.name}>\n          <HitCount />\n          <CustomHits lang={lang} />\n        </Index>\n      ))}\n      <CustomPoweredBy />\n    </div>\n  );\n};\n\nexport default SearchResult;\n","import { useEffect } from \"react\";\n\nconst events = [`mousedown`, `touchstart`];\n\nexport default (ref, onClickOutside) => {\n  const isOutside = element => !ref.current || !ref.current.contains(element);\n\n  const onClick = event => {\n    if (isOutside(event.target)) {\n      onClickOutside();\n    }\n  };\n\n  useEffect(() => {\n    for (const event of events) {\n      document.addEventListener(event, onClick);\n    }\n    return () => {\n      for (const event of events) document.removeEventListener(event, onClick);\n    };\n  });\n};\n","import React, { createRef, useState } from \"react\";\nimport algoliasearch from \"algoliasearch/lite\";\nimport { Configure, InstantSearch } from \"react-instantsearch-dom\";\n\nimport { useIntl } from \"../../contexts/IntlContext\";\n\nimport SearchBox from \"./search-box\";\nimport SearchResult from \"./search-result\";\nimport useClickOutside from \"./use-click-outside\";\n\nconst Search = ({ indices }) => {\n  const { lang } = useIntl();\n  const rootRef = createRef();\n  const [query, setQuery] = useState();\n  const [hasFocus, setFocus] = useState(false);\n  const searchClient = algoliasearch(\n    process.env.GATSBY_ALGOLIA_APP_ID,\n    process.env.GATSBY_ALGOLIA_SEARCH_KEY\n  );\n  useClickOutside(rootRef, () => setFocus(false));\n\n  return (\n    <>\n      {lang ? (\n        <div className=\"relative my-2.5 mr-6 ml-0\" ref={rootRef}>\n          <InstantSearch\n            searchClient={searchClient}\n            indexName={indices[0].name}\n            onSearchStateChange={({ query }) => setQuery(query)}\n          >\n            <Configure restrictSearchableAttributes={[`title_${lang}`]} />\n            <SearchBox onFocus={() => setFocus(true)} hasFocus={hasFocus} />\n            <SearchResult\n              show={query && query.length > 0 && hasFocus}\n              indices={indices}\n            />\n          </InstantSearch>\n        </div>\n      ) : null}\n    </>\n  );\n};\n\nexport default Search;\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 VisualARQLogo from \"./visualARQ-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            <VisualARQLogo 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":""}