{"version":3,"sources":["webpack:///./node_modules/events/events.js","webpack:///./node_modules/algoliasearch-helper/src/requestBuilder.js","webpack:///./node_modules/algoliasearch-helper/src/version.js","webpack:///./node_modules/algoliasearch-helper/src/algoliasearch.helper.js","webpack:///./node_modules/react-side-effect/lib/index.js","webpack:///./node_modules/core-js/modules/es.array.reduce-right.js","webpack:///./src/components/lands-logo.js","webpack:///./src/components/language.js","webpack:///./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectSpread.js","webpack:///./node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack:///./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack:///./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack:///./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","webpack:///./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack:///./node_modules/@babel/runtime/helpers/esm/createClass.js","webpack:///./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack:///./node_modules/@babel/runtime/helpers/esm/inherits.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/utils.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/createWidgetsManager.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/highlight.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/indexUtils.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/createInstantSearchManager.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/version.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/createStore.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/context.js","webpack:///./node_modules/react-instantsearch-core/dist/es/widgets/InstantSearch.js","webpack:///./node_modules/@babel/runtime/helpers/esm/extends.js","webpack:///./node_modules/react-instantsearch-core/dist/es/core/createConnector.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectConfigure.js","webpack:///./node_modules/react-instantsearch-core/dist/es/widgets/Configure.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectSearchBox.js","webpack:///./src/components/search/search-box.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectStateResults.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectHighlight.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectPoweredBy.js","webpack:///./node_modules/react-instantsearch-core/dist/es/connectors/connectHits.js","webpack:///./node_modules/react-instantsearch-core/dist/es/widgets/Index.js","webpack:///./src/components/search/algolia-logo.js","webpack:///./src/components/search/search-result.js","webpack:///./src/components/search/use-click-outside.js","webpack:///./src/components/search/index.js","webpack:///./src/components/header.js","webpack:///./src/components/layout.js","webpack:///./node_modules/algoliasearch-helper/src/functions/formatSort.js","webpack:///./node_modules/algoliasearch/dist/algoliasearch-lite.umd.js","webpack:///./node_modules/algoliasearch-helper/src/functions/merge.js","webpack:///./node_modules/algoliasearch-helper/src/functions/find.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/RefinementList.js","webpack:///./node_modules/algoliasearch-helper/src/DerivedHelper/index.js","webpack:///./node_modules/algoliasearch-helper/index.js","webpack:///./node_modules/algoliasearch-helper/src/functions/inherits.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/index.js","webpack:///./node_modules/algoliasearch-helper/src/functions/intersection.js","webpack:///./node_modules/algoliasearch-helper/src/utils/isValidUserToken.js","webpack:///./node_modules/algoliasearch-helper/src/functions/compact.js","webpack:///./node_modules/react-fast-compare/index.js","webpack:///./node_modules/algoliasearch-helper/src/functions/objectHasKeys.js","webpack:///./node_modules/algoliasearch-helper/src/functions/defaultsPure.js","webpack:///./node_modules/algoliasearch-helper/src/SearchResults/generate-hierarchical-tree.js","webpack:///./node_modules/algoliasearch-helper/src/functions/valToNumber.js","webpack:///./node_modules/algoliasearch-helper/src/functions/findIndex.js","webpack:///./node_modules/algoliasearch-helper/src/functions/omit.js","webpack:///./node_modules/react-helmet/es/Helmet.js","webpack:///./node_modules/algoliasearch-helper/src/SearchResults/index.js","webpack:///./src/components/seo.js","webpack:///./node_modules/algoliasearch-helper/src/functions/orderBy.js","webpack:///(webpack)/buildin/global.js"],"names":["ReflectOwnKeys","R","Reflect","ReflectApply","apply","target","receiver","args","Function","prototype","call","ownKeys","Object","getOwnPropertySymbols","getOwnPropertyNames","concat","NumberIsNaN","Number","isNaN","value","EventEmitter","init","this","module","exports","once","emitter","name","Promise","resolve","reject","eventListener","undefined","errorListener","removeListener","slice","arguments","err","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","TypeError","_getMaxListeners","that","_addListener","type","prepend","m","events","existing","warning","create","newListener","emit","unshift","push","length","warned","w","Error","String","count","console","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","arr","ret","Array","i","unwrapListeners","arrayClone","listenerCount","n","copy","defineProperty","enumerable","get","set","arg","RangeError","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","message","context","handler","len","listeners","addListener","on","prependListener","prependOnceListener","list","position","originalListener","shift","index","pop","spliceOne","off","removeAllListeners","key","keys","rawListeners","eventNames","merge","requestBuilder","_getQueries","queries","indexName","params","_getHitsSearchParams","getRefinedDisjunctiveFacets","forEach","refinedFacet","_getDisjunctiveFacetSearchParams","getRefinedHierarchicalFacets","hierarchicalFacet","getHierarchicalFacetByName","currentRefinement","getHierarchicalRefinement","separator","_getHierarchicalFacetSeparator","split","facets","disjunctiveFacets","_getHitsHierarchicalFacetsAttributes","facetFilters","_getFacetFilters","numericFilters","_getNumericFilters","additionalParams","tagFilters","_getTagFilters","getQueryParams","facet","hierarchicalRootLevel","hitsPerPage","page","attributesToRetrieve","attributesToHighlight","attributesToSnippet","analytics","clickAnalytics","_getDisjunctiveHierarchicalFacetAttribute","facetName","numericRefinements","attribute","operators","operator","values","isArray","vs","map","v","tagRefinements","join","facetsRefinements","facetValue","facetsExcludes","disjunctiveFacetsRefinements","facetValues","orFilters","hierarchicalFacetsRefinements","attributeToRefine","attributesIndex","rootPath","_getHierarchicalRootPath","indexOf","lastIndexOf","attributes","hierarchicalFacets","reduce","allAttributes","hierarchicalRefinement","level","newAttributes","rootLevel","attributeIndex","parentLevel","getSearchForFacetQuery","query","maxFacetHits","stateForSearchForFacetValues","isDisjunctiveFacet","clearRefinements","searchForFacetSearchParameters","facetQuery","SearchParameters","SearchResults","DerivedHelper","inherits","objectHasKeys","version","AlgoliaSearchHelper","client","options","addAlgoliaAgent","setClient","opts","make","lastResults","_queryId","_lastQueryIdReceived","derivedHelpers","_currentNbQueries","setCurrentPage","_change","setPage","isPageReset","getCurrentPage","search","_search","onlyWithDerivedHelpers","searchOnlyWithDerivedHelpers","getQuery","searchOnce","cb","tempState","setQueryParameters","self","then","content","results","_originalResponse","e","catch","searchForFacetValues","userState","clientHasSFFV","initIndex","isDisjunctive","algoliaQuery","facetHits","f","isRefined","isDisjunctiveFacetRefined","isFacetRefined","setQuery","q","resetPage","clearTags","addDisjunctiveFacetRefinement","addDisjunctiveRefine","addHierarchicalFacetRefinement","addNumericRefinement","addFacetRefinement","addRefine","addFacetExclusion","addExcludeRefinement","addExclude","addTag","tag","addTagRefinement","removeNumericRefinement","removeDisjunctiveFacetRefinement","removeDisjunctiveRefine","removeHierarchicalFacetRefinement","removeFacetRefinement","removeRefine","removeFacetExclusion","removeExcludeRefinement","removeExclude","removeTag","removeTagRefinement","toggleFacetExclusion","toggleExcludeFacetRefinement","toggleExclude","toggleRefinement","toggleFacetRefinement","toggleRefine","toggleTag","toggleTagRefinement","nextPage","previousPage","setIndex","setQueryParameter","parameter","setState","newState","overrideStateWithoutTriggeringChangeEvent","hasRefinements","getNumericRefinements","isConjunctiveFacet","isHierarchicalFacet","isHierarchicalFacetRefined","isExcluded","isExcludeRefined","isDisjunctiveRefined","hasTag","isTagRefined","hasTagRefinements","getIndex","getPage","getTags","getRefinements","refinements","getConjunctiveRefinements","r","getExcludeRefinements","getDisjunctiveRefinements","getNumericRefinement","getHierarchicalFacetBreadcrumb","states","mainQueries","queriesCount","helper","derivedQueries","derivedHelper","derivedState","getModifiedState","derivedStateQueries","queryId","_dispatchAlgoliaResponse","_dispatchAlgoliaError","s","specificResults","splice","formattedResponse","containsRefinement","_hasDisjunctiveRefinements","disjunctiveRefinements","event","clearCache","newClient","getClient","derive","fn","detachDerivedHelper","pos","hasPendingRequests","ex","React","React__default","_defineProperty","obj","configurable","writable","canUseDOM","window","document","createElement","reducePropsToState","handleStateChangeOnClient","mapStateOnServer","WrappedComponent","mountedInstances","emitChange","instance","props","SideEffect","_PureComponent","subClass","superClass","constructor","__proto__","peek","rewind","recordedState","_proto","UNSAFE_componentWillMount","componentDidUpdate","componentWillUnmount","render","PureComponent","displayName","getDisplayName","$","$reduceRight","right","arrayMethodIsStrict","arrayMethodUsesToLength","CHROME_VERSION","IS_NODE","STRICT_METHOD","USES_TO_LENGTH","1","proto","forced","reduceRight","callbackfn","LandsLogo","rootCssClasses","viewBox","className","opacity","fill","d","isolation","defaultProps","Language","useIntl","lang","storeLang","translations","languages","useStaticQuery","allLanguage","nodes","useMemo","translationsData","languagesData","find","l","locale","createLangOptions","htmlFor","id","onChange","navigate","_objectSpread","source","filter","sym","getOwnPropertyDescriptor","_classCallCheck","Constructor","_typeof","Symbol","iterator","_assertThisInitialized","ReferenceError","_possibleConstructorReturn","_getPrototypeOf","o","setPrototypeOf","_defineProperties","descriptor","_createClass","protoProps","staticProps","_setPrototypeOf","p","_inherits","_objectWithoutProperties","excluded","sourceKeys","sourceSymbolKeys","propertyIsEnumerable","shallowEqual","objA","objB","keysA","keysB","hasOwn","hasOwnProperty","resolved","removeEmptyKey","object","omit","_key","createWidgetsManager","onWidgetsUpdate","widgets","scheduled","scheduleUpdate","registerWidget","widget","update","getWidgets","HIGHLIGHT_TAGS","highlightPreTag","highlightPostTag","parseHighlightedAttribute","_ref","preTag","postTag","_ref$highlightedValue","highlightedValue","splitByPreTag","firstValue","elements","isHighlighted","splitByPostTag","parseAlgoliaHit","_ref2","_ref2$preTag","_ref2$postTag","highlightProperty","hit","path","highlightObject","replace","current","item","getIndexId","hasMultipleIndices","multiIndexContext","targetedIndex","ais","mainTargetedIndex","getResults","searchResults","hits","indexId","refineValue","searchState","nextRefinement","namespace","_objectSpread4","indices","refineMultiIndexWithNamespace","refineMultiIndex","refineSingleIndexWithNamespace","refineSingleIndex","getNamespaceAndAttributeName","parts","match","attributeName","getCurrentRefinementValue","defaultValue","_getNamespaceAndAttri","multiIndex","defaultRefinement","cleanUpValue","_getNamespaceAndAttri2","Boolean","_ref4","indexSearchState","cleanUpValueWithMultiIndex","_ref3","cleanUpValueWithSingleIndex","addAlgoliaAgents","searchClient","contextValue","indexContextValue","isTargetedIndexEqualIndex","isIndexWidget","isIndexWidgetEqualIndex","sortIndexWidgetsFirst","firstWidget","secondWidget","isFirstWidgetIndex","isSecondWidgetIndex","serializeQueryParameters","parameters","format","_len","encodeURIComponent","encode","toString","JSON","stringify","createInstantSearchManager","_ref$initialState","initialState","resultsState","stalledSearchDelay","stalledSearchTimer","setTimeout","_store$getState","store","getState","partialState","resultsFacetValues","isSearchStalled","handleSearchSuccess","handleSearchError","skip","initialSearchParameters","widgetsManager","metadata","getMetadata","searching","transporter","_cacheHydrated","_useCache","baseMethod","requests","_len2","methodArgs","_key2","requestsWithSerializedParams","request","responsesCache","method","acc","result","rawResults","cache","hydrateSearchClientWithMultiIndexRequest","hydrateSearchClientWithSingleIndexRequest","hydrateSearchClient","nextState","subscribe","createStore","hydrateMetadata","_internalIndexId","a","hydrateResultsState","searchingForFacetValues","getSearchParameters","sharedParameters","res","mainParameters","targetedIndexEqualMainIndex","subIndexEqualMainIndex","sort","derivedIndices","targetedIndexNotEqualMainIndex","subIndexNotEqualMainIndex","derivedParameters","_getSearchParameters","detach","isDerivedHelpersEmpty","getFacetByName","currentState","nextIsSearchStalled","clearTimeout","getWidgetsIds","meta","onSearchForFacetValues","_ref5","_ref5$maxFacetHits","maxFacetHitsWithinRange","Math","max","min","_objectSpread7","onExternalStateUpdate","nextSearchState","transitionState","updateClient","updateIndex","newIndex","skipSearch","datum","items","nestedItem","_createContext","onInternalStateUpdate","createHrefForState","onSearchStateChange","onSearchParameters","InstantSearchConsumer","Consumer","InstantSearchProvider","Provider","_createContext2","IndexConsumer","IndexProvider","isControlled","_Component","InstantSearch","_this","instantSearchManager","onWidgetsInternalStateUpdate","nextProps","prevState","nextIsControlled","previousSearchState","prevProps","prevIsControlled","refresh","isUnmounting","createURL","getKnownKeys","_searchState","widgetsCollector","_searchState2","children","string","isRequired","shape","func","bool","oneOfType","array","node","number","_extends","assign","createConnector","connectorDesc","Composed","Connector","isWidget","Component","providedProps","getProvidedProps","refine","_len3","_key3","_this2","unsubscribe","unregisterWidget","shouldComponentUpdate","propsEqual","cleanUp","_this$props$contextVa","searchParameters","nextWidgetsState","prevWidgetsState","_this$props","refineProps","searchForFacetValuesProps","searchForItems","propTypes","createConnectorWithoutContext","prevSearchState","propKeys","nonPresentKeys","_props","prop","subState","configureState","getCurrentRefinement","_refine","connectSearchBox","_cleanUp","label","onFocus","hasFocus","placeholder","aria-label","height","width","allSearchResults","_ref$preTag","_ref$postTag","highlight","hostname","location","url","queryID","__queryID","addQueryID","__position","getIndexContext","Index","indexContext","inferredIndexId","AlgoliaLogo","xmlns","baseProfile","x1","x2","y1","y2","gradientUnits","gradientTransform","offset","stopColor","HitCount","connectStateResults","hitCount","nbHits","CustomHighlight","connectHighlight","parsedHit","part","CustomPoweredBy","connectPoweredBy","href","rel","CustomHits","connectHits","objectID","to","SearchResult","show","ref","onClickOutside","onClick","element","contains","useEffect","addEventListener","removeEventListener","Search","rootRef","createRef","useState","setFocus","algoliasearch","process","useClickOutside","Configure","restrictSearchableAttributes","searchIndices","title","Header","siteTitle","defaultLang","site","siteMetadata","Layout","data","sortBy","defaults","defaultInstructions","out","sortInstruction","matchingDefault","defaultInstruction","t","getOwnPropertyDescriptors","defineProperties","u","next","done","return","from","localStorage","parse","getItem","miss","all","setItem","delete","clear","removeItem","caches","serializable","c","floor","random","h","entries","timeout","headers","queryParameters","cacheable","Read","Write","Any","g","status","lastUpdate","Date","now","b","protocol","accept","P","j","toLowerCase","userAgent","transporterStackTrace","A","S","connectTimeout","timeouts","connect","responseTimeout","response","host","triesLeft","onSucess","onRetry","isTimedOut","logger","info","x","hostsCache","onFail","requester","send","getTimeout","statelessHosts","reverse","add","segment","T","charAt","substr","N","appId","authMode","apiKey","requestsCache","hosts","read","mappedRequestOptions","write","methods","C","k","J","F","E","queryLanguages","I","H","XMLHttpRequest","open","setRequestHeader","abort","onreadystatechange","readyState","OPENED","onerror","responseText","onload","debug","multipleQueries","multipleSearchForFacetValues","findAnswers","isObjectOrArrayOrFunction","_merge","sourceVal","targetVal","comparator","defaultsPure","lib","addRefinement","refinementList","valueAsString","facetRefinement","mod","removeRefinement","clearRefinement","refinementType","hasChanged","newRefinementList","memo","facetList","refinementValue","containsRefinements","refinementValueAsString","mainHelper","main","algoliasearchHelper","ctor","superCtor","intersection","valToNumber","isValidUserToken","RefinementList","isEqualNumericRefinement","every","el","newParameters","_parseNumbers","userToken","paramName","isKeyKnown","PARAMETERS","isValueDefined","numbers","parsedValue","parseFloat","insideBoundingBox","geoRect","parsedValues","vPrime","toggleHierarchicalFacetRefinement","validate","patch","_clearNumericRefinements","newQuery","newPage","setFacets","setDisjunctiveFacets","setHitsPerPage","setTypoTolerance","typoTolerance","isNumericRefined","paramValue","op","val","newNumericRefinements","operatorList","outValues","addFacet","addDisjunctiveFacet","addHierarchicalFacet","modification","removeFacet","removeDisjunctiveFacet","removeHierarchicalFacet","toggleConjunctiveFacetRefinement","toggleDisjunctiveFacetRefinement","isOperatorDefined","searchedValue","isAttributeValueDefined","currentValue","disjunctiveNumericRefinedFacets","getUnrefinedDisjunctiveFacets","refinedFacets","managedParameters","queryParams","nextWithNumbers","previousPlainObject","nextPlainObject","previous","isPreviousValueDefined","isNextValueDefined","_getHierarchicalFacetSortBy","_getHierarchicalShowParentLevel","showParentLevel","hierarchicalFacetName","refinement","trim","arr1","arr2","test","hasElementType","Element","hasMap","Map","hasSet","Set","hasArrayBuffer","ArrayBuffer","isView","equal","it","size","has","RegExp","flags","valueOf","$$typeof","sources","hierarchicalFacetResult","hierarchicalFacetIndex","hierarchicalFacetRefinement","hierarchicalSeparator","hierarchicalRootPath","hierarchicalShowParentLevel","prepareHierarchicalFacetSortBy","rootExhaustive","facetResult","exhaustive","generateTreeFn","hierarchicalTree","currentHierarchicalLevel","parent","subtree","picked","tuple","parentPath","onlyMatchingTree","orderBy","facetCount","generateHierarchicalTree","clock","_class","_temp","ATTRIBUTE_NAMES","TAG_NAMES","BASE","BODY","HEAD","HTML","LINK","META","NOSCRIPT","SCRIPT","STYLE","TITLE","TAG_PROPERTIES","REACT_TAG_MAP","accesskey","charset","class","contenteditable","contextmenu","itemprop","tabindex","HELMET_PROPS","HTML_TAG_MAP","SELF_CLOSING_TAGS","classCallCheck","createClass","objectWithoutProperties","possibleConstructorReturn","encodeSpecialCharacters","str","getTitleFromPropsList","propsList","innermostTitle","getInnermostProperty","innermostTemplate","innermostDefaultTitle","getOnChangeClientState","getAttributesFromPropsList","tagType","tagAttrs","getBaseTagFromPropsList","primaryAttributes","innermostBaseTag","lowerCaseAttributeKey","getTagsFromPropsList","tagName","approvedSeenTags","approvedTags","instanceTags","instanceSeenTags","primaryAttributeKey","attributeKey","tagUnion","property","rafPolyfill","callback","currentTime","cafPolyfill","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","global","cancelAnimationFrame","webkitCancelAnimationFrame","mozCancelAnimationFrame","msg","_helmetCallback","commitTagChanges","baseTag","bodyAttributes","htmlAttributes","linkTags","metaTags","noscriptTags","onChangeClientState","scriptTags","styleTags","titleAttributes","updateAttributes","updateTitle","tagUpdates","updateTags","addedTags","removedTags","_tagUpdates$tagType","newTags","oldTags","flattenArray","possibleArray","elementTag","getElementsByTagName","helmetAttributeString","getAttribute","helmetAttributes","attributesToRemove","attributeKeys","setAttribute","indexToSave","_i","removeAttribute","tags","headElement","head","querySelector","tagNodes","querySelectorAll","indexToDelete","newElement","innerHTML","styleSheet","cssText","appendChild","createTextNode","some","existingTag","isEqualNode","parentNode","removeChild","generateElementAttributesAsString","attr","convertElementAttributestoReactProps","initProps","getMethodsForTag","toComponent","_initProps","attributeString","flattenedTitle","generateTitleAsString","_mappedTag","mappedTag","mappedAttribute","dangerouslySetInnerHTML","__html","generateTagsAsReactComponent","attributeHtml","tagContent","isSelfClosing","generateTagsAsString","_ref$title","base","link","noscript","script","style","HelmetSideEffects","defer","HelmetExport","_React$Component","HelmetWrapper","mapNestedChildrenToProps","child","nestedChildren","flattenArrayTypeChildren","_babelHelpers$extends","arrayTypeChildren","newChildProps","mapObjectTypeChildren","_babelHelpers$extends2","_babelHelpers$extends3","newProps","mapArrayTypeChildrenToProps","newFlattenedProps","arrayChildName","_babelHelpers$extends4","warnOnInvalidChildren","mapChildrenToProps","Children","_child$props","initAttributes","convertReactPropstoHtmlAttributes","arrayOf","defaultTitle","titleTemplate","mappedState","renderStatic","compact","findIndex","formatSort","getIndices","idx","assignFacetStats","dest","facetStats","stats","mainSubResponse","_rawResults","processingTimeMS","sum","facetsIndices","disjunctiveFacetsIndices","nextDisjunctiveResult","mainFacets","facetKey","hierarchicalAttributeName","facetValueObject","facetIndex","idxAttributeName","exhaustiveFacetsCount","isFacetDisjunctive","isFacetConjunctive","facets_stats","disjunctiveFacet","dfacet","facetResults","dataFromMainRequest","defaultData","root","excludes","_state","recSort","sortFn","childNode","sortedChildren","getFacetStatsIfAvailable","getRefinement","resultsFacets","predicate","DEFAULT_SORT","getFacetValues","extractNormalizedFacetValues","order","hierarchicalFacetValues","vanillaSortFn","getFacetStats","facetDeclaration","rootFacet","intermediateFacet","newFacet","numericValue","SEO","description","metaDescription","author","compareAscending","other","valIsDefined","valIsNull","othIsDefined","othIsNull","collection","iteratees","orders","criteria","iteratee"],"mappings":"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","file":"commons-1cee7437a9d779818902.js","sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null;\nvar ReflectApply = R && typeof R.apply === 'function' ? R.apply : function ReflectApply(target, receiver, args) {\n  return Function.prototype.apply.call(target, receiver, args);\n};\nvar ReflectOwnKeys;\n\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys;\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n};\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\n\nmodule.exports = EventEmitter;\nmodule.exports.once = once; // Backwards-compat with node 0.10.x\n\nEventEmitter.EventEmitter = EventEmitter;\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined; // By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\n\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function get() {\n    return defaultMaxListeners;\n  },\n  set: function set(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function () {\n  if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n}; // Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\n\n\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined) return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n\n  for (var i = 1; i < arguments.length; i++) {\n    args.push(arguments[i]);\n  }\n\n  var doError = type === 'error';\n  var events = this._events;\n  if (events !== undefined) doError = doError && events.error === undefined;else if (!doError) return false; // If there is no 'error' event listener then throw.\n\n  if (doError) {\n    var er;\n    if (args.length > 0) er = args[0];\n\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    } // At least give some kind of context to the user\n\n\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n  if (handler === undefined) return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n\n    for (var i = 0; i < len; ++i) {\n      ReflectApply(listeners[i], this, args);\n    }\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n  checkListener(listener);\n  events = target._events;\n\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type, listener.listener ? listener.listener : listener); // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n\n      events = target._events;\n    }\n\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] = prepend ? [listener, existing] : [existing, listener]; // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    } // Check for listener leak\n\n\n    m = _getMaxListeners(target);\n\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true; // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n\n      var w = new Error('Possible EventEmitter memory leak detected. ' + existing.length + ' ' + String(type) + ' listeners ' + 'added. Use emitter.setMaxListeners() to ' + 'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener = function prependListener(type, listener) {\n  return _addListener(this, type, listener, true);\n};\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0) return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = {\n    fired: false,\n    wrapFn: undefined,\n    target: target,\n    type: type,\n    listener: listener\n  };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {\n  checkListener(listener);\n  this.prependListener(type, _onceWrap(this, type, listener));\n  return this;\n}; // Emits a 'removeListener' event if and only if the listener was removed.\n\n\nEventEmitter.prototype.removeListener = function removeListener(type, listener) {\n  var list, events, position, i, originalListener;\n  checkListener(listener);\n  events = this._events;\n  if (events === undefined) return this;\n  list = events[type];\n  if (list === undefined) return this;\n\n  if (list === listener || list.listener === listener) {\n    if (--this._eventsCount === 0) this._events = Object.create(null);else {\n      delete events[type];\n      if (events.removeListener) this.emit('removeListener', type, list.listener || listener);\n    }\n  } else if (typeof list !== 'function') {\n    position = -1;\n\n    for (i = list.length - 1; i >= 0; i--) {\n      if (list[i] === listener || list[i].listener === listener) {\n        originalListener = list[i].listener;\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0) return this;\n    if (position === 0) list.shift();else {\n      spliceOne(list, position);\n    }\n    if (list.length === 1) events[type] = list[0];\n    if (events.removeListener !== undefined) this.emit('removeListener', type, originalListener || listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {\n  var listeners, events, i;\n  events = this._events;\n  if (events === undefined) return this; // not listening for removeListener, no need to emit\n\n  if (events.removeListener === undefined) {\n    if (arguments.length === 0) {\n      this._events = Object.create(null);\n      this._eventsCount = 0;\n    } else if (events[type] !== undefined) {\n      if (--this._eventsCount === 0) this._events = Object.create(null);else delete events[type];\n    }\n\n    return this;\n  } // emit removeListener for all listeners on all events\n\n\n  if (arguments.length === 0) {\n    var keys = Object.keys(events);\n    var key;\n\n    for (i = 0; i < keys.length; ++i) {\n      key = keys[i];\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n\n    this.removeAllListeners('removeListener');\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n    return this;\n  }\n\n  listeners = events[type];\n\n  if (typeof listeners === 'function') {\n    this.removeListener(type, listeners);\n  } else if (listeners !== undefined) {\n    // LIFO order\n    for (i = listeners.length - 1; i >= 0; i--) {\n      this.removeListener(type, listeners[i]);\n    }\n  }\n\n  return this;\n};\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n  if (events === undefined) return [];\n  var evlistener = events[type];\n  if (evlistener === undefined) return [];\n  if (typeof evlistener === 'function') return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function (emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\n\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n\n  for (var i = 0; i < n; ++i) {\n    copy[i] = arr[i];\n  }\n\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++) {\n    list[index] = list[index + 1];\n  }\n\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function eventListener() {\n      if (errorListener !== undefined) {\n        emitter.removeListener('error', errorListener);\n      }\n\n      resolve([].slice.call(arguments));\n    }\n\n    ;\n    var errorListener; // Adding an error listener is not optional because\n    // if an error is thrown on an event emitter we cannot\n    // guarantee that the actual event we are waiting will\n    // be fired. The result could be a silent way to create\n    // memory or file descriptor leaks, which is something\n    // we should avoid.\n\n    if (name !== 'error') {\n      errorListener = function errorListener(err) {\n        emitter.removeListener(name, eventListener);\n        reject(err);\n      };\n\n      emitter.once('error', errorListener);\n    }\n\n    emitter.once(name, eventListener);\n  });\n}","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar merge = require('./functions/merge');\n\nvar requestBuilder = {\n  /**\n   * Get all the queries to send to the client, those queries can used directly\n   * with the Algolia client.\n   * @private\n   * @return {object[]} The queries\n   */\n  _getQueries: function getQueries(index, state) {\n    var queries = []; // One query for the hits\n\n    queries.push({\n      indexName: index,\n      params: requestBuilder._getHitsSearchParams(state)\n    }); // One for each disjunctive facets\n\n    state.getRefinedDisjunctiveFacets().forEach(function (refinedFacet) {\n      queries.push({\n        indexName: index,\n        params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet)\n      });\n    }); // maybe more to get the root level of hierarchical facets when activated\n\n    state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {\n      var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n      var currentRefinement = state.getHierarchicalRefinement(refinedFacet); // if we are deeper than level 0 (starting from `beer > IPA`)\n      // we want to get the root values\n\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n      if (currentRefinement.length > 0 && currentRefinement[0].split(separator).length > 1) {\n        queries.push({\n          indexName: index,\n          params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet, true)\n        });\n      }\n    });\n    return queries;\n  },\n\n  /**\n   * Build search parameters used to fetch hits\n   * @private\n   * @return {object.<string, any>}\n   */\n  _getHitsSearchParams: function _getHitsSearchParams(state) {\n    var facets = state.facets.concat(state.disjunctiveFacets).concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state));\n\n    var facetFilters = requestBuilder._getFacetFilters(state);\n\n    var numericFilters = requestBuilder._getNumericFilters(state);\n\n    var tagFilters = requestBuilder._getTagFilters(state);\n\n    var additionalParams = {\n      facets: facets,\n      tagFilters: tagFilters\n    };\n\n    if (facetFilters.length > 0) {\n      additionalParams.facetFilters = facetFilters;\n    }\n\n    if (numericFilters.length > 0) {\n      additionalParams.numericFilters = numericFilters;\n    }\n\n    return merge({}, state.getQueryParams(), additionalParams);\n  },\n\n  /**\n   * Build search parameters used to fetch a disjunctive facet\n   * @private\n   * @param  {string} facet the associated facet name\n   * @param  {boolean} hierarchicalRootLevel ?? FIXME\n   * @return {object}\n   */\n  _getDisjunctiveFacetSearchParams: function _getDisjunctiveFacetSearchParams(state, facet, hierarchicalRootLevel) {\n    var facetFilters = requestBuilder._getFacetFilters(state, facet, hierarchicalRootLevel);\n\n    var numericFilters = requestBuilder._getNumericFilters(state, facet);\n\n    var tagFilters = requestBuilder._getTagFilters(state);\n\n    var additionalParams = {\n      hitsPerPage: 1,\n      page: 0,\n      attributesToRetrieve: [],\n      attributesToHighlight: [],\n      attributesToSnippet: [],\n      tagFilters: tagFilters,\n      analytics: false,\n      clickAnalytics: false\n    };\n    var hierarchicalFacet = state.getHierarchicalFacetByName(facet);\n\n    if (hierarchicalFacet) {\n      additionalParams.facets = requestBuilder._getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, hierarchicalRootLevel);\n    } else {\n      additionalParams.facets = facet;\n    }\n\n    if (numericFilters.length > 0) {\n      additionalParams.numericFilters = numericFilters;\n    }\n\n    if (facetFilters.length > 0) {\n      additionalParams.facetFilters = facetFilters;\n    }\n\n    return merge({}, state.getQueryParams(), additionalParams);\n  },\n\n  /**\n   * Return the numeric filters in an algolia request fashion\n   * @private\n   * @param {string} [facetName] the name of the attribute for which the filters should be excluded\n   * @return {string[]} the numeric filters in the algolia format\n   */\n  _getNumericFilters: function _getNumericFilters(state, facetName) {\n    if (state.numericFilters) {\n      return state.numericFilters;\n    }\n\n    var numericFilters = [];\n    Object.keys(state.numericRefinements).forEach(function (attribute) {\n      var operators = state.numericRefinements[attribute] || {};\n      Object.keys(operators).forEach(function (operator) {\n        var values = operators[operator] || [];\n\n        if (facetName !== attribute) {\n          values.forEach(function (value) {\n            if (Array.isArray(value)) {\n              var vs = value.map(function (v) {\n                return attribute + operator + v;\n              });\n              numericFilters.push(vs);\n            } else {\n              numericFilters.push(attribute + operator + value);\n            }\n          });\n        }\n      });\n    });\n    return numericFilters;\n  },\n\n  /**\n   * Return the tags filters depending\n   * @private\n   * @return {string}\n   */\n  _getTagFilters: function _getTagFilters(state) {\n    if (state.tagFilters) {\n      return state.tagFilters;\n    }\n\n    return state.tagRefinements.join(',');\n  },\n\n  /**\n   * Build facetFilters parameter based on current refinements. The array returned\n   * contains strings representing the facet filters in the algolia format.\n   * @private\n   * @param  {string} [facet] if set, the current disjunctive facet\n   * @return {array.<string>}\n   */\n  _getFacetFilters: function _getFacetFilters(state, facet, hierarchicalRootLevel) {\n    var facetFilters = [];\n    var facetsRefinements = state.facetsRefinements || {};\n    Object.keys(facetsRefinements).forEach(function (facetName) {\n      var facetValues = facetsRefinements[facetName] || [];\n      facetValues.forEach(function (facetValue) {\n        facetFilters.push(facetName + ':' + facetValue);\n      });\n    });\n    var facetsExcludes = state.facetsExcludes || {};\n    Object.keys(facetsExcludes).forEach(function (facetName) {\n      var facetValues = facetsExcludes[facetName] || [];\n      facetValues.forEach(function (facetValue) {\n        facetFilters.push(facetName + ':-' + facetValue);\n      });\n    });\n    var disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements || {};\n    Object.keys(disjunctiveFacetsRefinements).forEach(function (facetName) {\n      var facetValues = disjunctiveFacetsRefinements[facetName] || [];\n\n      if (facetName === facet || !facetValues || facetValues.length === 0) {\n        return;\n      }\n\n      var orFilters = [];\n      facetValues.forEach(function (facetValue) {\n        orFilters.push(facetName + ':' + facetValue);\n      });\n      facetFilters.push(orFilters);\n    });\n    var hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements || {};\n    Object.keys(hierarchicalFacetsRefinements).forEach(function (facetName) {\n      var facetValues = hierarchicalFacetsRefinements[facetName] || [];\n      var facetValue = facetValues[0];\n\n      if (facetValue === undefined) {\n        return;\n      }\n\n      var hierarchicalFacet = state.getHierarchicalFacetByName(facetName);\n\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n      var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n\n      var attributeToRefine;\n      var attributesIndex; // we ask for parent facet values only when the `facet` is the current hierarchical facet\n\n      if (facet === facetName) {\n        // if we are at the root level already, no need to ask for facet values, we get them from\n        // the hits query\n        if (facetValue.indexOf(separator) === -1 || !rootPath && hierarchicalRootLevel === true || rootPath && rootPath.split(separator).length === facetValue.split(separator).length) {\n          return;\n        }\n\n        if (!rootPath) {\n          attributesIndex = facetValue.split(separator).length - 2;\n          facetValue = facetValue.slice(0, facetValue.lastIndexOf(separator));\n        } else {\n          attributesIndex = rootPath.split(separator).length - 1;\n          facetValue = rootPath;\n        }\n\n        attributeToRefine = hierarchicalFacet.attributes[attributesIndex];\n      } else {\n        attributesIndex = facetValue.split(separator).length - 1;\n        attributeToRefine = hierarchicalFacet.attributes[attributesIndex];\n      }\n\n      if (attributeToRefine) {\n        facetFilters.push([attributeToRefine + ':' + facetValue]);\n      }\n    });\n    return facetFilters;\n  },\n  _getHitsHierarchicalFacetsAttributes: function _getHitsHierarchicalFacetsAttributes(state) {\n    var out = [];\n    return state.hierarchicalFacets.reduce( // ask for as much levels as there's hierarchical refinements\n    function getHitsAttributesForHierarchicalFacet(allAttributes, hierarchicalFacet) {\n      var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0]; // if no refinement, ask for root level\n\n      if (!hierarchicalRefinement) {\n        allAttributes.push(hierarchicalFacet.attributes[0]);\n        return allAttributes;\n      }\n\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n      var level = hierarchicalRefinement.split(separator).length;\n      var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);\n      return allAttributes.concat(newAttributes);\n    }, out);\n  },\n  _getDisjunctiveHierarchicalFacetAttribute: function _getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, rootLevel) {\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n    if (rootLevel === true) {\n      var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n\n      var attributeIndex = 0;\n\n      if (rootPath) {\n        attributeIndex = rootPath.split(separator).length;\n      }\n\n      return [hierarchicalFacet.attributes[attributeIndex]];\n    }\n\n    var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || ''; // if refinement is 'beers > IPA > Flying dog',\n    // then we want `facets: ['beers > IPA']` as disjunctive facet (parent level values)\n\n    var parentLevel = hierarchicalRefinement.split(separator).length - 1;\n    return hierarchicalFacet.attributes.slice(0, parentLevel + 1);\n  },\n  getSearchForFacetQuery: function getSearchForFacetQuery(facetName, query, maxFacetHits, state) {\n    var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ? state.clearRefinements(facetName) : state;\n    var searchForFacetSearchParameters = {\n      facetQuery: query,\n      facetName: facetName\n    };\n\n    if (typeof maxFacetHits === 'number') {\n      searchForFacetSearchParameters.maxFacetHits = maxFacetHits;\n    }\n\n    return merge({}, requestBuilder._getHitsSearchParams(stateForSearchForFacetValues), searchForFacetSearchParameters);\n  }\n};\nmodule.exports = requestBuilder;","'use strict';\n\nmodule.exports = '3.3.4';","'use strict';\n\nvar SearchParameters = require('./SearchParameters');\n\nvar SearchResults = require('./SearchResults');\n\nvar DerivedHelper = require('./DerivedHelper');\n\nvar requestBuilder = require('./requestBuilder');\n\nvar events = require('events');\n\nvar inherits = require('./functions/inherits');\n\nvar objectHasKeys = require('./functions/objectHasKeys');\n\nvar version = require('./version');\n/**\n * Event triggered when a parameter is set or updated\n * @event AlgoliaSearchHelper#event:change\n * @property {object} event\n * @property {SearchParameters} event.state the current parameters with the latest changes applied\n * @property {SearchResults} event.results the previous results received from Algolia. `null` before the first request\n * @example\n * helper.on('change', function(event) {\n *   console.log('The parameters have changed');\n * });\n */\n\n/**\n * Event triggered when a main search is sent to Algolia\n * @event AlgoliaSearchHelper#event:search\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search\n * @property {SearchResults} event.results the results from the previous search. `null` if it is the first search.\n * @example\n * helper.on('search', function(event) {\n *   console.log('Search sent');\n * });\n */\n\n/**\n * Event triggered when a search using `searchForFacetValues` is sent to Algolia\n * @event AlgoliaSearchHelper#event:searchForFacetValues\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search it is the first search.\n * @property {string} event.facet the facet searched into\n * @property {string} event.query the query used to search in the facets\n * @example\n * helper.on('searchForFacetValues', function(event) {\n *   console.log('searchForFacetValues sent');\n * });\n */\n\n/**\n * Event triggered when a search using `searchOnce` is sent to Algolia\n * @event AlgoliaSearchHelper#event:searchOnce\n * @property {object} event\n * @property {SearchParameters} event.state the parameters used for this search it is the first search.\n * @example\n * helper.on('searchOnce', function(event) {\n *   console.log('searchOnce sent');\n * });\n */\n\n/**\n * Event triggered when the results are retrieved from Algolia\n * @event AlgoliaSearchHelper#event:result\n * @property {object} event\n * @property {SearchResults} event.results the results received from Algolia\n * @property {SearchParameters} event.state the parameters used to query Algolia. Those might be different from the one in the helper instance (for example if the network is unreliable).\n * @example\n * helper.on('result', function(event) {\n *   console.log('Search results received');\n * });\n */\n\n/**\n * Event triggered when Algolia sends back an error. For example, if an unknown parameter is\n * used, the error can be caught using this event.\n * @event AlgoliaSearchHelper#event:error\n * @property {object} event\n * @property {Error} event.error the error returned by the Algolia.\n * @example\n * helper.on('error', function(event) {\n *   console.log('Houston we got a problem.');\n * });\n */\n\n/**\n * Event triggered when the queue of queries have been depleted (with any result or outdated queries)\n * @event AlgoliaSearchHelper#event:searchQueueEmpty\n * @example\n * helper.on('searchQueueEmpty', function() {\n *   console.log('No more search pending');\n *   // This is received before the result event if we're not expecting new results\n * });\n *\n * helper.search();\n */\n\n/**\n * Initialize a new AlgoliaSearchHelper\n * @class\n * @classdesc The AlgoliaSearchHelper is a class that ease the management of the\n * search. It provides an event based interface for search callbacks:\n *  - change: when the internal search state is changed.\n *    This event contains a {@link SearchParameters} object and the\n *    {@link SearchResults} of the last result if any.\n *  - search: when a search is triggered using the `search()` method.\n *  - result: when the response is retrieved from Algolia and is processed.\n *    This event contains a {@link SearchResults} object and the\n *    {@link SearchParameters} corresponding to this answer.\n *  - error: when the response is an error. This event contains the error returned by the server.\n * @param  {AlgoliaSearch} client an AlgoliaSearch client\n * @param  {string} index the index name to query\n * @param  {SearchParameters | object} options an object defining the initial\n * config of the search. It doesn't have to be a {SearchParameters},\n * just an object containing the properties you need from it.\n */\n\n\nfunction AlgoliaSearchHelper(client, index, options) {\n  if (typeof client.addAlgoliaAgent === 'function') {\n    client.addAlgoliaAgent('JS Helper (' + version + ')');\n  }\n\n  this.setClient(client);\n  var opts = options || {};\n  opts.index = index;\n  this.state = SearchParameters.make(opts);\n  this.lastResults = null;\n  this._queryId = 0;\n  this._lastQueryIdReceived = -1;\n  this.derivedHelpers = [];\n  this._currentNbQueries = 0;\n}\n\ninherits(AlgoliaSearchHelper, events.EventEmitter);\n/**\n * Start the search with the parameters set in the state. When the\n * method is called, it triggers a `search` event. The results will\n * be available through the `result` event. If an error occurs, an\n * `error` will be fired instead.\n * @return {AlgoliaSearchHelper}\n * @fires search\n * @fires result\n * @fires error\n * @chainable\n */\n\nAlgoliaSearchHelper.prototype.search = function () {\n  this._search({\n    onlyWithDerivedHelpers: false\n  });\n\n  return this;\n};\n\nAlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function () {\n  this._search({\n    onlyWithDerivedHelpers: true\n  });\n\n  return this;\n};\n/**\n * Gets the search query parameters that would be sent to the Algolia Client\n * for the hits\n * @return {object} Query Parameters\n */\n\n\nAlgoliaSearchHelper.prototype.getQuery = function () {\n  var state = this.state;\n  return requestBuilder._getHitsSearchParams(state);\n};\n/**\n * Start a search using a modified version of the current state. This method does\n * not trigger the helper lifecycle and does not modify the state kept internally\n * by the helper. This second aspect means that the next search call will be the\n * same as a search call before calling searchOnce.\n * @param {object} options can contain all the parameters that can be set to SearchParameters\n * plus the index\n * @param {function} [callback] optional callback executed when the response from the\n * server is back.\n * @return {promise|undefined} if a callback is passed the method returns undefined\n * otherwise it returns a promise containing an object with two keys :\n *  - content with a SearchResults\n *  - state with the state used for the query as a SearchParameters\n * @example\n * // Changing the number of records returned per page to 1\n * // This example uses the callback API\n * var state = helper.searchOnce({hitsPerPage: 1},\n *   function(error, content, state) {\n *     // if an error occurred it will be passed in error, otherwise its value is null\n *     // content contains the results formatted as a SearchResults\n *     // state is the instance of SearchParameters used for this search\n *   });\n * @example\n * // Changing the number of records returned per page to 1\n * // This example uses the promise API\n * var state1 = helper.searchOnce({hitsPerPage: 1})\n *                 .then(promiseHandler);\n *\n * function promiseHandler(res) {\n *   // res contains\n *   // {\n *   //   content : SearchResults\n *   //   state   : SearchParameters (the one used for this specific search)\n *   // }\n * }\n */\n\n\nAlgoliaSearchHelper.prototype.searchOnce = function (options, cb) {\n  var tempState = !options ? this.state : this.state.setQueryParameters(options);\n\n  var queries = requestBuilder._getQueries(tempState.index, tempState);\n\n  var self = this;\n  this._currentNbQueries++;\n  this.emit('searchOnce', {\n    state: tempState\n  });\n\n  if (cb) {\n    this.client.search(queries).then(function (content) {\n      self._currentNbQueries--;\n\n      if (self._currentNbQueries === 0) {\n        self.emit('searchQueueEmpty');\n      }\n\n      cb(null, new SearchResults(tempState, content.results), tempState);\n    }).catch(function (err) {\n      self._currentNbQueries--;\n\n      if (self._currentNbQueries === 0) {\n        self.emit('searchQueueEmpty');\n      }\n\n      cb(err, null, tempState);\n    });\n    return undefined;\n  }\n\n  return this.client.search(queries).then(function (content) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    return {\n      content: new SearchResults(tempState, content.results),\n      state: tempState,\n      _originalResponse: content\n    };\n  }, function (e) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    throw e;\n  });\n};\n/**\n * Structure of each result when using\n * [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)\n * @typedef FacetSearchHit\n * @type {object}\n * @property {string} value the facet value\n * @property {string} highlighted the facet value highlighted with the query string\n * @property {number} count number of occurrence of this facet value\n * @property {boolean} isRefined true if the value is already refined\n */\n\n/**\n * Structure of the data resolved by the\n * [`searchForFacetValues()`](reference.html#AlgoliaSearchHelper#searchForFacetValues)\n * promise.\n * @typedef FacetSearchResult\n * @type {object}\n * @property {FacetSearchHit} facetHits the results for this search for facet values\n * @property {number} processingTimeMS time taken by the query inside the engine\n */\n\n/**\n * Search for facet values based on an query and the name of a faceted attribute. This\n * triggers a search and will return a promise. On top of using the query, it also sends\n * the parameters from the state so that the search is narrowed down to only the possible values.\n *\n * See the description of [FacetSearchResult](reference.html#FacetSearchResult)\n * @param {string} facet the name of the faceted attribute\n * @param {string} query the string query for the search\n * @param {number} [maxFacetHits] the maximum number values returned. Should be > 0 and <= 100\n * @param {object} [userState] the set of custom parameters to use on top of the current state. Setting a property to `undefined` removes\n * it in the generated query.\n * @return {promise.<FacetSearchResult>} the results of the search\n */\n\n\nAlgoliaSearchHelper.prototype.searchForFacetValues = function (facet, query, maxFacetHits, userState) {\n  var clientHasSFFV = typeof this.client.searchForFacetValues === 'function';\n\n  if (!clientHasSFFV && typeof this.client.initIndex !== 'function') {\n    throw new Error('search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues or client.initIndex(index).searchForFacetValues');\n  }\n\n  var state = this.state.setQueryParameters(userState || {});\n  var isDisjunctive = state.isDisjunctiveFacet(facet);\n  var algoliaQuery = requestBuilder.getSearchForFacetQuery(facet, query, maxFacetHits, state);\n  this._currentNbQueries++;\n  var self = this;\n  this.emit('searchForFacetValues', {\n    state: state,\n    facet: facet,\n    query: query\n  });\n  var searchForFacetValuesPromise = clientHasSFFV ? this.client.searchForFacetValues([{\n    indexName: state.index,\n    params: algoliaQuery\n  }]) : this.client.initIndex(state.index).searchForFacetValues(algoliaQuery);\n  return searchForFacetValuesPromise.then(function addIsRefined(content) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    content = Array.isArray(content) ? content[0] : content;\n    content.facetHits.forEach(function (f) {\n      f.isRefined = isDisjunctive ? state.isDisjunctiveFacetRefined(facet, f.value) : state.isFacetRefined(facet, f.value);\n    });\n    return content;\n  }, function (e) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n    throw e;\n  });\n};\n/**\n * Sets the text query used for the search.\n *\n * This method resets the current page to 0.\n * @param  {string} q the user query\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.setQuery = function (q) {\n  this._change({\n    state: this.state.resetPage().setQuery(q),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Remove all the types of refinements except tags. A string can be provided to remove\n * only the refinements of a specific attribute. For more advanced use case, you can\n * provide a function instead. This function should follow the\n * [clearCallback definition](#SearchParameters.clearCallback).\n *\n * This method resets the current page to 0.\n * @param {string} [name] optional name of the facet / attribute on which we want to remove all refinements\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n * @example\n * // Removing all the refinements\n * helper.clearRefinements().search();\n * @example\n * // Removing all the filters on a the category attribute.\n * helper.clearRefinements('category').search();\n * @example\n * // Removing only the exclude filters on the category facet.\n * helper.clearRefinements(function(value, attribute, type) {\n *   return type === 'exclude' && attribute === 'category';\n * }).search();\n */\n\n\nAlgoliaSearchHelper.prototype.clearRefinements = function (name) {\n  this._change({\n    state: this.state.resetPage().clearRefinements(name),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Remove all the tag filters.\n *\n * This method resets the current page to 0.\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.clearTags = function () {\n  this._change({\n    state: this.state.resetPage().clearTags(),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Adds a disjunctive filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addDisjunctiveFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addDisjunctiveFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.addDisjunctiveRefine = function () {\n  return this.addDisjunctiveFacetRefinement.apply(this, arguments);\n};\n/**\n * Adds a refinement on a hierarchical facet. It will throw\n * an exception if the facet is not defined or if the facet\n * is already refined.\n *\n * This method resets the current page to 0.\n * @param {string} facet the facet name\n * @param {string} path the hierarchical facet path\n * @return {AlgoliaSearchHelper}\n * @throws Error if the facet is not defined or if the facet is refined\n * @chainable\n * @fires change\n */\n\n\nAlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addHierarchicalFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Adds a an numeric filter to an attribute with the `operator` and `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} attribute the attribute on which the numeric filter applies\n * @param  {string} operator the operator of the filter\n * @param  {number} value the value of the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addNumericRefinement = function (attribute, operator, value) {\n  this._change({\n    state: this.state.resetPage().addNumericRefinement(attribute, operator, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Adds a filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.addRefine = function () {\n  return this.addFacetRefinement.apply(this, arguments);\n};\n/**\n * Adds a an exclusion filter to a faceted attribute with the `value` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value (will be converted to string)\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addFacetExclusion = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().addExcludeRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetExclusion}\n */\n\n\nAlgoliaSearchHelper.prototype.addExclude = function () {\n  return this.addFacetExclusion.apply(this, arguments);\n};\n/**\n * Adds a tag filter with the `tag` provided. If the\n * filter is already set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param {string} tag the tag to add to the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.addTag = function (tag) {\n  this._change({\n    state: this.state.resetPage().addTagRefinement(tag),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Removes an numeric filter to an attribute with the `operator` and `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * Some parameters are optional, triggering different behavior:\n *  - if the value is not provided, then all the numeric value will be removed for the\n *  specified attribute/operator couple.\n *  - if the operator is not provided either, then all the numeric filter on this attribute\n *  will be removed.\n *\n * This method resets the current page to 0.\n * @param  {string} attribute the attribute on which the numeric filter applies\n * @param  {string} [operator] the operator of the filter\n * @param  {number} [value] the value of the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeNumericRefinement = function (attribute, operator, value) {\n  this._change({\n    state: this.state.resetPage().removeNumericRefinement(attribute, operator, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Removes a disjunctive filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().removeDisjunctiveFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeDisjunctiveFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function () {\n  return this.removeDisjunctiveFacetRefinement.apply(this, arguments);\n};\n/**\n * Removes the refinement set on a hierarchical facet.\n * @param {string} facet the facet name\n * @return {AlgoliaSearchHelper}\n * @throws Error if the facet is not defined or if the facet is not refined\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function (facet) {\n  this._change({\n    state: this.state.resetPage().removeHierarchicalFacetRefinement(facet),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Removes a filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().removeFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.removeRefine = function () {\n  return this.removeFacetRefinement.apply(this, arguments);\n};\n/**\n * Removes an exclusion filter to a faceted attribute with the `value` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * If the value is omitted, then this method will remove all the filters for the\n * attribute.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} [value] the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeFacetExclusion = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().removeExcludeRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetExclusion}\n */\n\n\nAlgoliaSearchHelper.prototype.removeExclude = function () {\n  return this.removeFacetExclusion.apply(this, arguments);\n};\n/**\n * Removes a tag filter with the `tag` provided. If the\n * filter is not set, it doesn't change the filters.\n *\n * This method resets the current page to 0.\n * @param {string} tag tag to remove from the filter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.removeTag = function (tag) {\n  this._change({\n    state: this.state.resetPage().removeTagRefinement(tag),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Adds or removes an exclusion filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.toggleFacetExclusion = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().toggleExcludeFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetExclusion}\n */\n\n\nAlgoliaSearchHelper.prototype.toggleExclude = function () {\n  return this.toggleFacetExclusion.apply(this, arguments);\n};\n/**\n * Adds or removes a filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method can be used for conjunctive, disjunctive and hierarchical filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper}\n * @throws Error will throw an error if the facet is not declared in the settings of the helper\n * @fires change\n * @chainable\n * @deprecated since version 2.19.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.toggleRefinement = function (facet, value) {\n  return this.toggleFacetRefinement(facet, value);\n};\n/**\n * Adds or removes a filter to a faceted attribute with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method can be used for conjunctive, disjunctive and hierarchical filters.\n *\n * This method resets the current page to 0.\n * @param  {string} facet the facet to refine\n * @param  {string} value the associated value\n * @return {AlgoliaSearchHelper}\n * @throws Error will throw an error if the facet is not declared in the settings of the helper\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.toggleFacetRefinement = function (facet, value) {\n  this._change({\n    state: this.state.resetPage().toggleFacetRefinement(facet, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}\n */\n\n\nAlgoliaSearchHelper.prototype.toggleRefine = function () {\n  return this.toggleFacetRefinement.apply(this, arguments);\n};\n/**\n * Adds or removes a tag filter with the `value` provided. If\n * the value is set then it removes it, otherwise it adds the filter.\n *\n * This method resets the current page to 0.\n * @param {string} tag tag to remove or add\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.toggleTag = function (tag) {\n  this._change({\n    state: this.state.resetPage().toggleTagRefinement(tag),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Increments the page number by one.\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n * @example\n * helper.setPage(0).nextPage().getPage();\n * // returns 1\n */\n\n\nAlgoliaSearchHelper.prototype.nextPage = function () {\n  var page = this.state.page || 0;\n  return this.setPage(page + 1);\n};\n/**\n * Decrements the page number by one.\n * @fires change\n * @return {AlgoliaSearchHelper}\n * @chainable\n * @example\n * helper.setPage(1).previousPage().getPage();\n * // returns 0\n */\n\n\nAlgoliaSearchHelper.prototype.previousPage = function () {\n  var page = this.state.page || 0;\n  return this.setPage(page - 1);\n};\n/**\n * @private\n */\n\n\nfunction setCurrentPage(page) {\n  if (page < 0) throw new Error('Page requested below 0.');\n\n  this._change({\n    state: this.state.setPage(page),\n    isPageReset: false\n  });\n\n  return this;\n}\n/**\n * Change the current page\n * @deprecated\n * @param  {number} page The page number\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.setCurrentPage = setCurrentPage;\n/**\n * Updates the current page.\n * @function\n * @param  {number} page The page number\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\nAlgoliaSearchHelper.prototype.setPage = setCurrentPage;\n/**\n * Updates the name of the index that will be targeted by the query.\n *\n * This method resets the current page to 0.\n * @param {string} name the index name\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\nAlgoliaSearchHelper.prototype.setIndex = function (name) {\n  this._change({\n    state: this.state.resetPage().setIndex(name),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Update a parameter of the search. This method reset the page\n *\n * The complete list of parameters is available on the\n * [Algolia website](https://www.algolia.com/doc/rest#query-an-index).\n * The most commonly used parameters have their own [shortcuts](#query-parameters-shortcuts)\n * or benefit from higher-level APIs (all the kind of filters and facets have their own API)\n *\n * This method resets the current page to 0.\n * @param {string} parameter name of the parameter to update\n * @param {any} value new value of the parameter\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n * @example\n * helper.setQueryParameter('hitsPerPage', 20).search();\n */\n\n\nAlgoliaSearchHelper.prototype.setQueryParameter = function (parameter, value) {\n  this._change({\n    state: this.state.resetPage().setQueryParameter(parameter, value),\n    isPageReset: true\n  });\n\n  return this;\n};\n/**\n * Set the whole state (warning: will erase previous state)\n * @param {SearchParameters} newState the whole new state\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.setState = function (newState) {\n  this._change({\n    state: SearchParameters.make(newState),\n    isPageReset: false\n  });\n\n  return this;\n};\n/**\n * Override the current state without triggering a change event.\n * Do not use this method unless you know what you are doing. (see the example\n * for a legit use case)\n * @param {SearchParameters} newState the whole new state\n * @return {AlgoliaSearchHelper}\n * @example\n *  helper.on('change', function(state){\n *    // In this function you might want to find a way to store the state in the url/history\n *    updateYourURL(state)\n *  })\n *  window.onpopstate = function(event){\n *    // This is naive though as you should check if the state is really defined etc.\n *    helper.overrideStateWithoutTriggeringChangeEvent(event.state).search()\n *  }\n * @chainable\n */\n\n\nAlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function (newState) {\n  this.state = new SearchParameters(newState);\n  return this;\n};\n/**\n * Check if an attribute has any numeric, conjunctive, disjunctive or hierarchical filters.\n * @param {string} attribute the name of the attribute\n * @return {boolean} true if the attribute is filtered by at least one value\n * @example\n * // hasRefinements works with numeric, conjunctive, disjunctive and hierarchical filters\n * helper.hasRefinements('price'); // false\n * helper.addNumericRefinement('price', '>', 100);\n * helper.hasRefinements('price'); // true\n *\n * helper.hasRefinements('color'); // false\n * helper.addFacetRefinement('color', 'blue');\n * helper.hasRefinements('color'); // true\n *\n * helper.hasRefinements('material'); // false\n * helper.addDisjunctiveFacetRefinement('material', 'plastic');\n * helper.hasRefinements('material'); // true\n *\n * helper.hasRefinements('categories'); // false\n * helper.toggleFacetRefinement('categories', 'kitchen > knife');\n * helper.hasRefinements('categories'); // true\n *\n */\n\n\nAlgoliaSearchHelper.prototype.hasRefinements = function (attribute) {\n  if (objectHasKeys(this.state.getNumericRefinements(attribute))) {\n    return true;\n  } else if (this.state.isConjunctiveFacet(attribute)) {\n    return this.state.isFacetRefined(attribute);\n  } else if (this.state.isDisjunctiveFacet(attribute)) {\n    return this.state.isDisjunctiveFacetRefined(attribute);\n  } else if (this.state.isHierarchicalFacet(attribute)) {\n    return this.state.isHierarchicalFacetRefined(attribute);\n  } // there's currently no way to know that the user did call `addNumericRefinement` at some point\n  // thus we cannot distinguish if there once was a numeric refinement that was cleared\n  // so we will return false in every other situations to be consistent\n  // while what we should do here is throw because we did not find the attribute in any type\n  // of refinement\n\n\n  return false;\n};\n/**\n * Check if a value is excluded for a specific faceted attribute. If the value\n * is omitted then the function checks if there is any excluding refinements.\n *\n * @param  {string}  facet name of the attribute for used for faceting\n * @param  {string}  [value] optional value. If passed will test that this value\n   * is filtering the given facet.\n * @return {boolean} true if refined\n * @example\n * helper.isExcludeRefined('color'); // false\n * helper.isExcludeRefined('color', 'blue') // false\n * helper.isExcludeRefined('color', 'red') // false\n *\n * helper.addFacetExclusion('color', 'red');\n *\n * helper.isExcludeRefined('color'); // true\n * helper.isExcludeRefined('color', 'blue') // false\n * helper.isExcludeRefined('color', 'red') // true\n */\n\n\nAlgoliaSearchHelper.prototype.isExcluded = function (facet, value) {\n  return this.state.isExcludeRefined(facet, value);\n};\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasRefinements}\n */\n\n\nAlgoliaSearchHelper.prototype.isDisjunctiveRefined = function (facet, value) {\n  return this.state.isDisjunctiveFacetRefined(facet, value);\n};\n/**\n * Check if the string is a currently filtering tag.\n * @param {string} tag tag to check\n * @return {boolean}\n */\n\n\nAlgoliaSearchHelper.prototype.hasTag = function (tag) {\n  return this.state.isTagRefined(tag);\n};\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasTag}\n */\n\n\nAlgoliaSearchHelper.prototype.isTagRefined = function () {\n  return this.hasTagRefinements.apply(this, arguments);\n};\n/**\n * Get the name of the currently used index.\n * @return {string}\n * @example\n * helper.setIndex('highestPrice_products').getIndex();\n * // returns 'highestPrice_products'\n */\n\n\nAlgoliaSearchHelper.prototype.getIndex = function () {\n  return this.state.index;\n};\n\nfunction getCurrentPage() {\n  return this.state.page;\n}\n/**\n * Get the currently selected page\n * @deprecated\n * @return {number} the current page\n */\n\n\nAlgoliaSearchHelper.prototype.getCurrentPage = getCurrentPage;\n/**\n * Get the currently selected page\n * @function\n * @return {number} the current page\n */\n\nAlgoliaSearchHelper.prototype.getPage = getCurrentPage;\n/**\n * Get all the tags currently set to filters the results.\n *\n * @return {string[]} The list of tags currently set.\n */\n\nAlgoliaSearchHelper.prototype.getTags = function () {\n  return this.state.tagRefinements;\n};\n/**\n * Get the list of refinements for a given attribute. This method works with\n * conjunctive, disjunctive, excluding and numerical filters.\n *\n * See also SearchResults#getRefinements\n *\n * @param {string} facetName attribute name used for faceting\n * @return {Array.<FacetRefinement|NumericRefinement>} All Refinement are objects that contain a value, and\n * a type. Numeric also contains an operator.\n * @example\n * helper.addNumericRefinement('price', '>', 100);\n * helper.getRefinements('price');\n * // [\n * //   {\n * //     \"value\": [\n * //       100\n * //     ],\n * //     \"operator\": \">\",\n * //     \"type\": \"numeric\"\n * //   }\n * // ]\n * @example\n * helper.addFacetRefinement('color', 'blue');\n * helper.addFacetExclusion('color', 'red');\n * helper.getRefinements('color');\n * // [\n * //   {\n * //     \"value\": \"blue\",\n * //     \"type\": \"conjunctive\"\n * //   },\n * //   {\n * //     \"value\": \"red\",\n * //     \"type\": \"exclude\"\n * //   }\n * // ]\n * @example\n * helper.addDisjunctiveFacetRefinement('material', 'plastic');\n * // [\n * //   {\n * //     \"value\": \"plastic\",\n * //     \"type\": \"disjunctive\"\n * //   }\n * // ]\n */\n\n\nAlgoliaSearchHelper.prototype.getRefinements = function (facetName) {\n  var refinements = [];\n\n  if (this.state.isConjunctiveFacet(facetName)) {\n    var conjRefinements = this.state.getConjunctiveRefinements(facetName);\n    conjRefinements.forEach(function (r) {\n      refinements.push({\n        value: r,\n        type: 'conjunctive'\n      });\n    });\n    var excludeRefinements = this.state.getExcludeRefinements(facetName);\n    excludeRefinements.forEach(function (r) {\n      refinements.push({\n        value: r,\n        type: 'exclude'\n      });\n    });\n  } else if (this.state.isDisjunctiveFacet(facetName)) {\n    var disjRefinements = this.state.getDisjunctiveRefinements(facetName);\n    disjRefinements.forEach(function (r) {\n      refinements.push({\n        value: r,\n        type: 'disjunctive'\n      });\n    });\n  }\n\n  var numericRefinements = this.state.getNumericRefinements(facetName);\n  Object.keys(numericRefinements).forEach(function (operator) {\n    var value = numericRefinements[operator];\n    refinements.push({\n      value: value,\n      operator: operator,\n      type: 'numeric'\n    });\n  });\n  return refinements;\n};\n/**\n * Return the current refinement for the (attribute, operator)\n * @param {string} attribute attribute in the record\n * @param {string} operator operator applied on the refined values\n * @return {Array.<number|number[]>} refined values\n */\n\n\nAlgoliaSearchHelper.prototype.getNumericRefinement = function (attribute, operator) {\n  return this.state.getNumericRefinement(attribute, operator);\n};\n/**\n * Get the current breadcrumb for a hierarchical facet, as an array\n * @param  {string} facetName Hierarchical facet name\n * @return {array.<string>} the path as an array of string\n */\n\n\nAlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function (facetName) {\n  return this.state.getHierarchicalFacetBreadcrumb(facetName);\n}; // /////////// PRIVATE\n\n/**\n * Perform the underlying queries\n * @private\n * @return {undefined}\n * @fires search\n * @fires result\n * @fires error\n */\n\n\nAlgoliaSearchHelper.prototype._search = function (options) {\n  var state = this.state;\n  var states = [];\n  var mainQueries = [];\n\n  if (!options.onlyWithDerivedHelpers) {\n    mainQueries = requestBuilder._getQueries(state.index, state);\n    states.push({\n      state: state,\n      queriesCount: mainQueries.length,\n      helper: this\n    });\n    this.emit('search', {\n      state: state,\n      results: this.lastResults\n    });\n  }\n\n  var derivedQueries = this.derivedHelpers.map(function (derivedHelper) {\n    var derivedState = derivedHelper.getModifiedState(state);\n\n    var derivedStateQueries = requestBuilder._getQueries(derivedState.index, derivedState);\n\n    states.push({\n      state: derivedState,\n      queriesCount: derivedStateQueries.length,\n      helper: derivedHelper\n    });\n    derivedHelper.emit('search', {\n      state: derivedState,\n      results: derivedHelper.lastResults\n    });\n    return derivedStateQueries;\n  });\n  var queries = Array.prototype.concat.apply(mainQueries, derivedQueries);\n  var queryId = this._queryId++;\n  this._currentNbQueries++;\n\n  try {\n    this.client.search(queries).then(this._dispatchAlgoliaResponse.bind(this, states, queryId)).catch(this._dispatchAlgoliaError.bind(this, queryId));\n  } catch (error) {\n    // If we reach this part, we're in an internal error state\n    this.emit('error', {\n      error: error\n    });\n  }\n};\n/**\n * Transform the responses as sent by the server and transform them into a user\n * usable object that merge the results of all the batch requests. It will dispatch\n * over the different helper + derived helpers (when there are some).\n * @private\n * @param {array.<{SearchParameters, AlgoliaQueries, AlgoliaSearchHelper}>}\n *  state state used for to generate the request\n * @param {number} queryId id of the current request\n * @param {object} content content of the response\n * @return {undefined}\n */\n\n\nAlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function (states, queryId, content) {\n  // FIXME remove the number of outdated queries discarded instead of just one\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= queryId - this._lastQueryIdReceived;\n  this._lastQueryIdReceived = queryId;\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n  var results = content.results.slice();\n  states.forEach(function (s) {\n    var state = s.state;\n    var queriesCount = s.queriesCount;\n    var helper = s.helper;\n    var specificResults = results.splice(0, queriesCount);\n    var formattedResponse = helper.lastResults = new SearchResults(state, specificResults);\n    helper.emit('result', {\n      results: formattedResponse,\n      state: state\n    });\n  });\n};\n\nAlgoliaSearchHelper.prototype._dispatchAlgoliaError = function (queryId, error) {\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= queryId - this._lastQueryIdReceived;\n  this._lastQueryIdReceived = queryId;\n  this.emit('error', {\n    error: error\n  });\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n};\n\nAlgoliaSearchHelper.prototype.containsRefinement = function (query, facetFilters, numericFilters, tagFilters) {\n  return query || facetFilters.length !== 0 || numericFilters.length !== 0 || tagFilters.length !== 0;\n};\n/**\n * Test if there are some disjunctive refinements on the facet\n * @private\n * @param {string} facet the attribute to test\n * @return {boolean}\n */\n\n\nAlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function (facet) {\n  return this.state.disjunctiveRefinements[facet] && this.state.disjunctiveRefinements[facet].length > 0;\n};\n\nAlgoliaSearchHelper.prototype._change = function (event) {\n  var state = event.state;\n  var isPageReset = event.isPageReset;\n\n  if (state !== this.state) {\n    this.state = state;\n    this.emit('change', {\n      state: this.state,\n      results: this.lastResults,\n      isPageReset: isPageReset\n    });\n  }\n};\n/**\n * Clears the cache of the underlying Algolia client.\n * @return {AlgoliaSearchHelper}\n */\n\n\nAlgoliaSearchHelper.prototype.clearCache = function () {\n  this.client.clearCache && this.client.clearCache();\n  return this;\n};\n/**\n * Updates the internal client instance. If the reference of the clients\n * are equal then no update is actually done.\n * @param  {AlgoliaSearch} newClient an AlgoliaSearch client\n * @return {AlgoliaSearchHelper}\n */\n\n\nAlgoliaSearchHelper.prototype.setClient = function (newClient) {\n  if (this.client === newClient) return this;\n\n  if (typeof newClient.addAlgoliaAgent === 'function') {\n    newClient.addAlgoliaAgent('JS Helper (' + version + ')');\n  }\n\n  this.client = newClient;\n  return this;\n};\n/**\n * Gets the instance of the currently used client.\n * @return {AlgoliaSearch}\n */\n\n\nAlgoliaSearchHelper.prototype.getClient = function () {\n  return this.client;\n};\n/**\n * Creates an derived instance of the Helper. A derived helper\n * is a way to request other indices synchronised with the lifecycle\n * of the main Helper. This mechanism uses the multiqueries feature\n * of Algolia to aggregate all the requests in a single network call.\n *\n * This method takes a function that is used to create a new SearchParameter\n * that will be used to create requests to Algolia. Those new requests\n * are created just before the `search` event. The signature of the function\n * is `SearchParameters -> SearchParameters`.\n *\n * This method returns a new DerivedHelper which is an EventEmitter\n * that fires the same `search`, `result` and `error` events. Those\n * events, however, will receive data specific to this DerivedHelper\n * and the SearchParameters that is returned by the call of the\n * parameter function.\n * @param {function} fn SearchParameters -> SearchParameters\n * @return {DerivedHelper}\n */\n\n\nAlgoliaSearchHelper.prototype.derive = function (fn) {\n  var derivedHelper = new DerivedHelper(this, fn);\n  this.derivedHelpers.push(derivedHelper);\n  return derivedHelper;\n};\n/**\n * This method detaches a derived Helper from the main one. Prefer using the one from the\n * derived helper itself, to remove the event listeners too.\n * @private\n * @return {undefined}\n * @throws Error\n */\n\n\nAlgoliaSearchHelper.prototype.detachDerivedHelper = function (derivedHelper) {\n  var pos = this.derivedHelpers.indexOf(derivedHelper);\n  if (pos === -1) throw new Error('Derived helper already detached');\n  this.derivedHelpers.splice(pos, 1);\n};\n/**\n * This method returns true if there is currently at least one on-going search.\n * @return {boolean} true if there is a search pending\n */\n\n\nAlgoliaSearchHelper.prototype.hasPendingRequests = function () {\n  return this._currentNbQueries > 0;\n};\n/**\n * @typedef AlgoliaSearchHelper.NumericRefinement\n * @type {object}\n * @property {number[]} value the numbers that are used for filtering this attribute with\n * the operator specified.\n * @property {string} operator the faceting data: value, number of entries\n * @property {string} type will be 'numeric'\n */\n\n/**\n * @typedef AlgoliaSearchHelper.FacetRefinement\n * @type {object}\n * @property {string} value the string use to filter the attribute\n * @property {string} type the type of filter: 'conjunctive', 'disjunctive', 'exclude'\n */\n\n\nmodule.exports = AlgoliaSearchHelper;","'use strict';\n\nfunction _interopDefault(ex) {\n  return ex && typeof ex === 'object' && 'default' in ex ? ex['default'] : ex;\n}\n\nvar React = require('react');\n\nvar React__default = _interopDefault(React);\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nvar canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient, mapStateOnServer) {\n  if (typeof reducePropsToState !== 'function') {\n    throw new Error('Expected reducePropsToState to be a function.');\n  }\n\n  if (typeof handleStateChangeOnClient !== 'function') {\n    throw new Error('Expected handleStateChangeOnClient to be a function.');\n  }\n\n  if (typeof mapStateOnServer !== 'undefined' && typeof mapStateOnServer !== 'function') {\n    throw new Error('Expected mapStateOnServer to either be undefined or a function.');\n  }\n\n  function getDisplayName(WrappedComponent) {\n    return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n  }\n\n  return function wrap(WrappedComponent) {\n    if (typeof WrappedComponent !== 'function') {\n      throw new Error('Expected WrappedComponent to be a React component.');\n    }\n\n    var mountedInstances = [];\n    var state;\n\n    function emitChange() {\n      state = reducePropsToState(mountedInstances.map(function (instance) {\n        return instance.props;\n      }));\n\n      if (SideEffect.canUseDOM) {\n        handleStateChangeOnClient(state);\n      } else if (mapStateOnServer) {\n        state = mapStateOnServer(state);\n      }\n    }\n\n    var SideEffect = /*#__PURE__*/function (_PureComponent) {\n      _inheritsLoose(SideEffect, _PureComponent);\n\n      function SideEffect() {\n        return _PureComponent.apply(this, arguments) || this;\n      } // Try to use displayName of wrapped component\n      // Expose canUseDOM so tests can monkeypatch it\n\n\n      SideEffect.peek = function peek() {\n        return state;\n      };\n\n      SideEffect.rewind = function rewind() {\n        if (SideEffect.canUseDOM) {\n          throw new Error('You may only call rewind() on the server. Call peek() to read the current state.');\n        }\n\n        var recordedState = state;\n        state = undefined;\n        mountedInstances = [];\n        return recordedState;\n      };\n\n      var _proto = SideEffect.prototype;\n\n      _proto.UNSAFE_componentWillMount = function UNSAFE_componentWillMount() {\n        mountedInstances.push(this);\n        emitChange();\n      };\n\n      _proto.componentDidUpdate = function componentDidUpdate() {\n        emitChange();\n      };\n\n      _proto.componentWillUnmount = function componentWillUnmount() {\n        var index = mountedInstances.indexOf(this);\n        mountedInstances.splice(index, 1);\n        emitChange();\n      };\n\n      _proto.render = function render() {\n        return /*#__PURE__*/React__default.createElement(WrappedComponent, this.props);\n      };\n\n      return SideEffect;\n    }(React.PureComponent);\n\n    _defineProperty(SideEffect, \"displayName\", \"SideEffect(\" + getDisplayName(WrappedComponent) + \")\");\n\n    _defineProperty(SideEffect, \"canUseDOM\", canUseDOM);\n\n    return SideEffect;\n  };\n}\n\nmodule.exports = withSideEffect;","'use strict';\nvar $ = require('../internals/export');\nvar $reduceRight = require('../internals/array-reduce').right;\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\nvar arrayMethodUsesToLength = require('../internals/array-method-uses-to-length');\nvar CHROME_VERSION = require('../internals/engine-v8-version');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar STRICT_METHOD = arrayMethodIsStrict('reduceRight');\n// For preventing possible almost infinite loop in non-standard implementations, test the forward version of the method\nvar USES_TO_LENGTH = arrayMethodUsesToLength('reduce', { 1: 0 });\n// Chrome 80-82 has a critical bug\n// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982\nvar CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83;\n\n// `Array.prototype.reduceRight` method\n// https://tc39.es/ecma262/#sec-array.prototype.reduceright\n$({ target: 'Array', proto: true, forced: !STRICT_METHOD || !USES_TO_LENGTH || CHROME_BUG }, {\n  reduceRight: function reduceRight(callbackfn /* , initialValue */) {\n    return $reduceRight(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n","import React from \"react\";\r\nimport PropTypes from \"prop-types\";\r\n\r\nconst LandsLogo = ({ rootCssClasses }) => (\r\n  <svg viewBox=\"0 0 615 115\" className={rootCssClasses}>\r\n    <g opacity=\".7\">\r\n      <path fill=\"#dfdd00\" d=\"M34.39.7s-7.2,36.4,10.2,60,54,20.1,54,20.1c0,0,5.7-18.9-6.1-40.8S53.69,11.9,44.69,8.4c-4.1-1.6-7.7-4.2-10.3-7.7Z\"/>\r\n      <path fill=\"#dfdd00\" d=\"M93.49,81.1c-5.2,0-10.4-.4-15.5-1.3-10.4-1.9-24.6-6.7-33.7-19s-11.2-28-11.6-39c-.2-7.1.2-14.2,1.4-21.2L34.19,0l.4.5c2.6,3.4,6.1,6.1,10.2,7.6,1.2.5,2.9,1,4.7,1.6,11.5,3.9,33,11.1,43.2,30.1,4.8,8.8,7.4,18.7,7.5,28.7.1,4.1-.4,8.3-1.4,12.3v.2h-.2s-2,.1-5.1.1ZM34.49,1.3c-1.1,6.8-1.5,13.6-1.3,20.5.4,10.9,2.6,26.5,11.6,38.7s23.1,16.9,33.3,18.8c6.7,1.2,13.5,1.6,20.2,1.2.9-3.9,1.4-8,1.3-12-.1-9.9-2.7-19.7-7.4-28.5-10-18.7-31.4-25.9-42.9-29.8-1.9-.6-3.5-1.2-4.8-1.7-3.9-1.4-7.3-3.9-10-7.2Z\"/>\r\n    </g>\r\n    <path fill=\"#fff\" d=\"M100.19,68.5c-.1-10-2.7-19.9-7.5-28.7-10.2-18.9-31.7-26.1-43.2-30-1.9-.7-3.5-1.2-4.7-1.7-4-1.5-7.6-4.1-10.2-7.6l-.3-.5-.1.6c-1.2,7-1.7,14.1-1.4,21.2.3,11,2.6,26.7,11.7,39s23.3,17.1,33.7,19c5.1.9,10.3,1.4,15.5,1.4,3.1,0,5-.2,5.1-.2h.2v-.2c.8-4,1.2-8.1,1.2-12.3ZM92.19,40.1c.8,1.5,1.5,3,2.2,4.5h-.1c-.3,16.6-5.7,27.4-6.7,29.4-5-3.4-9.7-7.3-14.2-11.4,1.3-2.7,9.8-20.6,8.1-35.7,4.4,3.7,8,8.2,10.7,13.2ZM35.69,40.5c10.2,6.4,23.2,7,23.4,7.1h0c1.6,2.2,3.3,4.2,5,6.1,2.9,3.3,5.8,6.2,8.6,8.8-2.8,0-19.8-.2-29.9-5-3.2-5.2-5.6-11-7.1-17ZM33.19,22.3c2.7,1.8,5.6,3.4,8.6,4.6,1.3.5,2.6,1,3.7,1.3.5.2,1,.3,1.5.4,3.5,6.4,7.4,12.5,11.6,18.4-2.1-.1-13.8-1.2-23-7.2-1.4-5.7-2.2-11.6-2.4-17.5ZM59.09,46.7c-4.3-5.9-8.2-12-11.6-18.4.1-.2.3-.5.5-.8,1.8-2.9,6.3-10.4,4.3-16.2,3.6,1.2,7.8,2.8,12.2,4.8,1.6,12-4.2,27.5-5.4,30.6ZM64.49,53.4c-1.7-1.9-3.4-4-5-6.2.9-2.3,7.1-18.2,5.5-30.9,5.8,2.6,11.2,6.1,16.1,10.2h-.1c1.9,14.8-6.4,32.7-7.9,35.8-2.8-2.7-5.7-5.7-8.6-8.9ZM44.59,8.6c1.3.5,2.9,1,4.8,1.7l2.3.8v.1c2.2,5.6-2.4,13.2-4.1,16.1l-.4.5c-4.7-8.6-8.9-17.4-12.6-26.5,2.6,3.3,6.1,5.8,10,7.3ZM34.39,2.3c3.7,8.8,7.8,17.4,12.4,25.8-4.8-1.4-9.4-3.6-13.5-6.4-.3-6.6.1-13,1.1-19.4ZM44.79,60.5c-.5-.7-1-1.4-1.5-2.2,10.4,4.6,27.2,4.8,29.5,4.8h.4c4.4,4.1,9,7.8,13.9,11.2-8,1.4-16.2,1.6-24.2.4-7.1-3.1-13.4-8-18.1-14.2ZM78.09,79.2c-4.6-.8-9.1-2.1-13.4-3.8,3,.4,6,.5,9,.5,4.7,0,9.4-.4,14-1.3h0c3.2,2.2,6.5,4.1,9.9,5.9-6.5.3-13.1-.1-19.5-1.3ZM98.39,80.3c-3.6-1.8-7-3.8-10.3-6.1,1-1.8,6.2-12.4,6.7-28.6,3.1,7.3,4.7,15.1,4.8,22.9.1,4-.3,8-1.2,11.8Z\"/>\r\n    <g opacity=\".7\">\r\n      <path fill=\"#91af1c\" d=\"M18.09,16.7s-7.2,36.4,10.2,60,54,20.1,54,20.1c0,0,5.7-18.8-6.1-40.8S37.39,27.9,28.39,24.4c-4.1-1.5-7.7-4.2-10.3-7.7Z\"/>\r\n      <path fill=\"#91af1c\" d=\"M77.19,97.2c-5.2,0-10.4-.5-15.5-1.4-10.4-1.9-24.6-6.7-33.7-19s-11.3-28-11.6-39c-.2-7.1.2-14.2,1.4-21.2l.1-.6.3.5c2.6,3.4,6.1,6.1,10.2,7.6,1.2.5,2.9,1,4.7,1.7,11.5,3.9,33,11.1,43.2,30.1,4.8,8.8,7.4,18.7,7.5,28.7.1,4.1-.4,8.3-1.4,12.3v.2h-.2c.1-.1-1.9.1-5,.1ZM18.19,17.3c-1.1,6.8-1.5,13.6-1.3,20.5.3,11,2.6,26.5,11.6,38.7s23.1,16.9,33.3,18.8c6.7,1.2,13.4,1.6,20.2,1.2.9-3.9,1.4-7.9,1.3-11.9-.1-9.9-2.7-19.7-7.4-28.4-10.1-18.8-31.4-26-42.9-29.8-1.9-.6-3.5-1.2-4.8-1.7-3.9-1.6-7.3-4.1-10-7.4Z\"/>\r\n    </g>\r\n    <path fill=\"#fff\" d=\"M83.79,84.6c-.1-10-2.7-19.9-7.5-28.7-10.1-19-31.6-26.2-43.1-30.1-1.9-.6-3.5-1.2-4.7-1.7-4-1.5-7.6-4.1-10.2-7.6l-.3-.5-.1.6c-1.2,7-1.7,14.1-1.4,21.2.3,11,2.6,26.7,11.7,39,9.1,12.3,23.3,17.1,33.7,19,5.1.9,10.3,1.4,15.5,1.4,3.1,0,5-.2,5.1-.2h.2v-.2c.8-4,1.2-8.1,1.1-12.2ZM75.89,56.1c.8,1.5,1.5,3,2.2,4.5h0c-.3,16.6-5.7,27.4-6.7,29.3-5-3.4-9.8-7.2-14.2-11.4,1.3-2.7,9.8-20.6,8.1-35.7,4.3,3.8,7.9,8.3,10.6,13.3ZM19.39,56.6c10.2,6.4,23.2,7,23.4,7h0c1.6,2.2,3.3,4.2,5,6.1,2.9,3.3,5.8,6.2,8.6,8.8-2.8,0-19.8-.2-29.9-5-3.3-5.3-5.6-11-7.1-16.9ZM42.79,62.7c-4.3-5.9-8.1-12-11.6-18.4.1-.2.3-.5.5-.8,1.8-2.9,6.3-10.4,4.3-16.2,4.1,1.4,8.2,3,12.1,4.8,1.7,12.1-4.1,27.5-5.3,30.6ZM42.39,63.1c-2.2-.2-14-1.3-23.2-7.2-1.3-5.7-2.1-11.6-2.3-17.5,2.7,1.9,5.6,3.4,8.7,4.6,1.3.5,2.6,1,3.6,1.3.5.2,1,.3,1.5.4,3.6,6.3,7.4,12.5,11.7,18.4ZM48.19,69.4c-1.7-2-3.4-4-5-6.2.9-2.3,7.1-18.2,5.5-30.9,5.8,2.6,11.2,6.1,16.1,10.2h-.1c1.9,14.8-6.4,32.7-7.9,35.8-2.8-2.7-5.7-5.7-8.6-8.9ZM28.29,24.6c1.3.5,2.9,1,4.8,1.7l2.3.8v.1c2.3,5.6-2.4,13.2-4.1,16.1l-.4.5c-4.7-8.6-8.9-17.4-12.6-26.4,2.6,3.2,6.1,5.7,10,7.2ZM18.09,18.3c3.7,8.8,7.8,17.4,12.4,25.8-4.8-1.4-9.4-3.6-13.5-6.4-.3-6.5.1-13,1.1-19.4ZM28.49,76.5c-.5-.7-1-1.4-1.5-2.2,10.4,4.6,27.2,4.8,29.5,4.8h.4c4.4,4.1,9,7.8,13.9,11.2-8,1.4-16.2,1.6-24.3.4-7.1-3.1-13.3-8-18-14.2ZM61.79,95.3c-4.6-.8-9.1-2.1-13.4-3.9,3,.4,6,.5,9,.5,4.7,0,9.4-.4,14-1.3h0c3.1,2.2,6.4,4.1,9.8,5.9-6.5.4-13-.1-19.4-1.2ZM82.09,96.4c-3.6-1.8-7-3.8-10.3-6.1,1-1.8,6.2-12.4,6.8-28.6,3.1,7.3,4.7,15.1,4.8,22.9,0,3.9-.4,7.9-1.3,11.8Z\"/>\r\n    <path fill=\"#4ca92b\" opacity=\".8\" d=\"M1.79,32.7s-7.2,36.4,10.2,60,54,20.1,54,20.1c0,0,5.6-18.8-6.1-40.8S21.09,43.9,12.09,40.4c-4.1-1.5-7.7-4.2-10.3-7.7Z\"/>\r\n    <path fill=\"#fff\" d=\"M67.49,100.6c-.1-10-2.7-19.9-7.5-28.7-10.1-19-31.6-26.2-43.1-30.1-1.9-.6-3.5-1.2-4.7-1.7-4-1.5-7.6-4.1-10.2-7.6l-.4-.5-.1.6C.29,39.6-.21,46.7.09,53.7c.3,11,2.6,26.7,11.7,39s23.3,17.1,33.7,19c5.1.9,10.3,1.4,15.4,1.4,3.1,0,5-.2,5.1-.2h.2v-.1c.9-4,1.4-8.1,1.3-12.2h0ZM59.59,72.1c.8,1.5,1.6,3,2.2,4.5h-.1c-.3,16.6-5.7,27.4-6.7,29.3-5-3.4-9.7-7.2-14.2-11.4,1.3-2.7,9.8-20.6,8.1-35.7,4.4,3.8,8,8.3,10.7,13.3ZM3.09,72.6c10.2,6.4,23.2,7,23.3,7h0c1.6,2.1,3.3,4.2,5,6.1,2.9,3.3,5.8,6.2,8.6,8.8-2.8,0-19.8-.2-29.9-5-3.2-5.2-5.5-11-7-16.9ZM.59,54.3c2.7,1.8,5.6,3.4,8.6,4.6,1.3.5,2.6,1,3.6,1.3.5.2,1,.3,1.5.4,3.5,6.4,7.4,12.5,11.7,18.4-2.2-.2-14-1.3-23.2-7.2-1.2-5.7-2-11.6-2.2-17.5ZM26.49,78.7c-4.3-5.9-8.1-12-11.6-18.4.1-.2.3-.5.5-.8,1.7-2.9,6.3-10.4,4.3-16.2,3.6,1.2,7.8,2.8,12.1,4.8,1.7,12.1-4.1,27.5-5.3,30.6ZM31.89,85.4c-1.7-2-3.4-4-5-6.2.9-2.3,7.1-18.2,5.5-30.9,5.8,2.6,11.2,6.1,16.1,10.2h-.1c1.9,14.8-6.4,32.7-7.9,35.8-2.8-2.7-5.7-5.6-8.6-8.9ZM11.99,40.6c1.3.5,2.9,1,4.8,1.7l2.3.8v.1c2.3,5.6-2.4,13.2-4.1,16.1-.2.2-.4.4-.4.5-4.7-8.6-8.9-17.4-12.6-26.4,2.6,3.2,6,5.7,10,7.2ZM1.79,34.3c3.7,8.8,7.8,17.4,12.4,25.8-4.8-1.4-9.4-3.6-13.5-6.4-.3-6.5.1-13,1.1-19.4ZM12.19,92.5c-.5-.7-1-1.4-1.5-2.2,10.4,4.6,27.2,4.8,29.6,4.8h.3c4.4,4,9.1,7.8,14,11.2-8,1.4-16.2,1.6-24.2.4-7.2-3.1-13.5-8-18.2-14.2ZM45.49,111.3c-4.6-.8-9.1-2.1-13.4-3.9,3,.4,6,.5,9,.5,4.7,0,9.4-.4,14-1.3h0c3.1,2.2,6.4,4.1,9.8,5.9-6.5.4-13,0-19.4-1.2ZM65.79,112.4c-3.6-1.8-7-3.8-10.3-6.1,1-1.8,6.2-12.4,6.8-28.6,3.1,7.3,4.7,15,4.8,22.9,0,3.9-.4,7.9-1.3,11.8Z\"/>\r\n    <g isolation=\"isolate\">\r\n      <g isolation=\"isolate\">\r\n        <path fill=\"#383636\" d=\"M153.32,24.77c4.28,3.51,6.42,8.44,6.42,14.78v2.86c0,4.43-1.22,8.34-3.67,11.74-2.44,3.4-5.96,5.79-10.54,7.16l19.47,34.59h-10.88l-18.21-32.53c-.61.08-1.83.11-3.67.11-3.05,0-6.07-.11-9.05-.34v32.76h-9.74V19.96c8.55-.3,15.2-.46,19.93-.46,9.01,0,15.65,1.76,19.93,5.27h0ZM123.19,27.98v27.03c4.12.38,7.56.57,10.31.57,11,0,16.5-4.47,16.5-13.4v-2.29c0-4.12-1.34-7.18-4.01-9.16-2.67-1.99-6.95-2.98-12.83-2.98-2.52,0-5.84.08-9.97.23Z\"/>\r\n        <path fill=\"#383636\" d=\"M184.48,47.45c4.2-5.88,9.09-8.82,14.66-8.82,4.89,0,8.65,1.66,11.28,4.98s3.95,8.04,3.95,14.15v38.15h-9.74v-36.77c0-7.64-2.48-11.46-7.45-11.46-2.22,0-4.47.84-6.76,2.52s-4.28,3.97-5.96,6.87v38.83h-9.74V17.67h9.74v29.78h.02Z\"/>\r\n        <path fill=\"#383636\" d=\"M239.41,18.82c1.11.92,1.66,2.22,1.66,3.89v3.32c0,1.68-.55,2.96-1.66,3.84-1.11.88-2.69,1.32-4.75,1.32s-3.53-.44-4.64-1.32-1.66-2.16-1.66-3.84v-3.32c0-1.68.55-2.98,1.66-3.89,1.11-.92,2.65-1.38,4.64-1.38s3.65.46,4.75,1.38ZM239.58,40.01v55.9h-9.74v-55.9h9.74Z\"/>\r\n        <path fill=\"#383636\" d=\"M291.3,43.62c2.63,3.32,3.95,8.04,3.95,14.15v38.15h-9.74v-36.77c0-7.64-2.48-11.46-7.45-11.46-2.22,0-4.47.84-6.76,2.52s-4.28,3.97-5.96,6.87v38.83h-9.74v-55.9h9.16v8.36c2.06-3.13,4.37-5.54,6.93-7.22s5.33-2.52,8.3-2.52c4.89,0,8.65,1.66,11.28,4.98h.03Z\"/>\r\n        <path fill=\"#383636\" d=\"M345.48,44.08c3.32,3.63,4.98,8.76,4.98,15.41v16.95c0,6.64-1.66,11.78-4.98,15.41-3.32,3.63-8.38,5.44-15.18,5.44s-11.86-1.81-15.18-5.44c-3.32-3.63-4.98-8.76-4.98-15.41v-16.95c0-6.64,1.66-11.78,4.98-15.41s8.38-5.44,15.18-5.44,11.86,1.82,15.18,5.44ZM322.63,49.87c-1.83,2.06-2.75,5-2.75,8.82v18.56c0,3.82.92,6.76,2.75,8.82s4.39,3.09,7.67,3.09,5.84-1.03,7.67-3.09c1.83-2.06,2.75-5,2.75-8.82v-18.67c0-3.82-.92-6.74-2.75-8.76-1.83-2.02-4.39-3.04-7.67-3.04s-5.84,1.03-7.67,3.09Z\"/>\r\n      </g>\r\n      <g isolation=\"isolate\">\r\n        <path fill=\"#383636\" d=\"M375.65,20.88v66.44h29.78v8.59h-39.52V20.88h9.74Z\"/>\r\n      </g>\r\n      <g isolation=\"isolate\">\r\n        <path fill=\"#383636\" d=\"M448.44,43.04c3.02,2.94,4.52,7.62,4.52,14.03v38.83h-9.28v-8.93c-4.43,6.87-9.43,10.31-15.01,10.31-4.43,0-7.96-1.53-10.6-4.58-2.63-3.05-3.95-7.22-3.95-12.49v-3.21c0-4.58,1.56-8.38,4.7-11.4,3.13-3.02,7.33-4.52,12.6-4.52,2.9,0,6.83.5,11.8,1.49v-6.3c0-3.28-.75-5.65-2.23-7.1-1.49-1.45-3.8-2.18-6.93-2.18-3.67,0-8.82.57-15.46,1.72v-8.36c7.18-1.15,12.33-1.72,15.46-1.72,6.57,0,11.36,1.47,14.38,4.41h0ZM426.5,71.16c-1.68,1.68-2.52,4.05-2.52,7.1v1.26c0,2.83.65,5.04,1.95,6.64,1.3,1.6,2.94,2.41,4.92,2.41s4.18-.9,6.36-2.69,4.18-4.33,6.01-7.62v-8.82c-2.9-.53-6.03-.8-9.39-.8s-5.65.84-7.33,2.52h0Z\"/>\r\n        <path fill=\"#383636\" d=\"M504.11,43.62c2.63,3.32,3.95,8.04,3.95,14.15v38.15h-9.74v-36.77c0-7.64-2.48-11.46-7.45-11.46-2.22,0-4.47.84-6.76,2.52s-4.28,3.97-5.96,6.87v38.83h-9.74v-55.9h9.16v8.36c2.06-3.13,4.37-5.54,6.93-7.22s5.33-2.52,8.3-2.52c4.89,0,8.65,1.66,11.28,4.98h.03Z\"/>\r\n        <path fill=\"#383636\" d=\"M562.59,95.91h-9.28v-9.05c-4.58,6.95-9.81,10.42-15.69,10.42-4.74,0-8.36-1.62-10.88-4.87-2.52-3.24-3.78-8-3.78-14.26v-20.39c0-6.03,1.39-10.73,4.18-14.09s6.78-5.04,11.97-5.04c2.21,0,4.54.56,6.99,1.66,2.44,1.11,4.7,2.46,6.76,4.07v-26.69h9.74v78.24h0ZM534.93,50.26c-1.49,1.95-2.23,4.91-2.23,8.88v17.76c0,7.79,2.41,11.68,7.22,11.68,2.29,0,4.56-.9,6.82-2.69,2.25-1.79,4.3-4.33,6.13-7.62v-25.2c-1.6-1.68-3.49-3.05-5.67-4.12s-4.14-1.6-5.9-1.6c-2.75,0-4.87.97-6.36,2.92h-.01Z\"/>\r\n        <path fill=\"#383636\" d=\"M606.23,40.01l-.23,8.25c-3.97-.92-7.6-1.38-10.88-1.38-6.87,0-10.31,2.22-10.31,6.64v1.03c0,1.38.36,2.48,1.09,3.32.72.84,2.04,1.72,3.95,2.63l10.77,5.04c6.49,3.05,9.74,7.52,9.74,13.4v2.52c-.08,5.27-1.66,9.22-4.75,11.86s-7.96,3.95-14.6,3.95c-3.44,0-8.36-.8-14.78-2.41l.46-8.71c5.73,1.68,10.42,2.52,14.09,2.52s6.34-.52,7.79-1.55c1.45-1.03,2.18-2.73,2.18-5.1v-1.15c0-1.83-.36-3.28-1.09-4.35-.73-1.07-1.93-1.98-3.61-2.75l-11.11-4.93c-3.36-1.53-5.82-3.36-7.39-5.5s-2.35-4.62-2.35-7.45v-1.6c.15-5.19,1.78-9.11,4.87-11.74,3.09-2.63,7.96-3.95,14.61-3.95,3.21,0,7.06.46,11.57,1.38l-.02.03Z\"/>\r\n      </g>\r\n    </g>\r\n  </svg>\r\n);\r\n\r\nLandsLogo.propTypes = {\r\n  rootCssClasses: PropTypes.string,\r\n};\r\n\r\nLandsLogo.defaultProps = {\r\n  rootCssClasses: \"\",\r\n};\r\n\r\nexport default LandsLogo;\r\n","/* eslint-disable jsx-a11y/no-onchange */\r\n\r\nimport React, { useMemo } from \"react\";\r\nimport { navigate, useStaticQuery, graphql } from \"gatsby\";\r\n\r\nimport { useIntl } from \"../contexts/IntlContext\";\r\n\r\n/**\r\n * Creates the list of language options for each translation available.\r\n * @param {Object} translationsData Keys are the locales and value is the path {<locale>: <path>}\r\n * @param {Object[]} languagesData Each object has a 'locale' ex: en-us, and 'name' ex: English\r\n */\r\nconst createLangOptions = (translationsData, languagesData) => {\r\n  const options = [];\r\n  for (const key of Object.keys(translationsData)) {\r\n    options.push(\r\n      <option value={key} key={key}>\r\n        {languagesData.find(l => l.locale === key)?.name ?? key}\r\n      </option>\r\n    );\r\n  }\r\n  return options;\r\n};\r\n\r\nconst Language = () => {\r\n  const { lang, storeLang, translations } = useIntl();\r\n\r\n  const {\r\n    allLanguage: { nodes: languages },\r\n  } = useStaticQuery(graphql`\r\n    query LanguagesQuery {\r\n      allLanguage {\r\n        nodes {\r\n          locale\r\n          name\r\n        }\r\n      }\r\n    }\r\n  `);\r\n\r\n  const options = useMemo(() => createLangOptions(translations, languages), [\r\n    translations,\r\n  ]);\r\n\r\n  return (\r\n    <>\r\n      {Object.keys(translations).length > 0 ? (\r\n        <form className=\"relative\">\r\n          <label htmlFor=\"lang\" className=\"sr-only\">\r\n            Language picker\r\n          </label>\r\n          <select\r\n            name=\"lang\"\r\n            id=\"lang\"\r\n            className=\"appearance-none block bg-transparent pr-6 py-1 text-gray-500 font-medium focus:outline-none focus:text-gray-900 cursor-pointer transition-colors duration-200\"\r\n            value={lang}\r\n            onChange={e => {\r\n              const lang = e.target.value;\r\n              navigate(translations[lang]);\r\n              storeLang(lang);\r\n            }}\r\n          >\r\n            {options}\r\n          </select>\r\n          <svg\r\n            className=\"w-5 h-5 text-gray-500 absolute top-1/2 right-0 -mt-2.5 pointer-events-none\"\r\n            fill=\"currentColor\"\r\n          >\r\n            <path d=\"M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z\" />\r\n          </svg>\r\n        </form>\r\n      ) : null}\r\n    </>\r\n  );\r\n};\r\n\r\nexport default Language;\r\n","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}","import defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nexport default function _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? Object(arguments[i]) : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}","export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}","import _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nexport default function _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"@babel/runtime/helpers/esm/setPrototypeOf\";\nexport default function _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}","import objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nexport default function _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}","import \"core-js/modules/es.array.reduce.js\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\"; // From https://github.com/reactjs/react-redux/blob/master/src/utils/shallowEqual.js\n\nexport var shallowEqual = function shallowEqual(objA, objB) {\n  if (objA === objB) {\n    return true;\n  }\n\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  } // Test for A's keys different from B.\n\n\n  var hasOwn = Object.prototype.hasOwnProperty;\n\n  for (var i = 0; i < keysA.length; i++) {\n    if (!hasOwn.call(objB, keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {\n      return false;\n    }\n  }\n\n  return true;\n};\nexport var getDisplayName = function getDisplayName(Component) {\n  return Component.displayName || Component.name || 'UnknownComponent';\n};\nvar resolved = Promise.resolve();\nexport var defer = function defer(f) {\n  resolved.then(f);\n};\n\nvar isPlainObject = function isPlainObject(value) {\n  return _typeof(value) === 'object' && value !== null && !Array.isArray(value);\n};\n\nexport var removeEmptyKey = function removeEmptyKey(obj) {\n  Object.keys(obj).forEach(function (key) {\n    var value = obj[key];\n\n    if (!isPlainObject(value)) {\n      return;\n    }\n\n    if (!objectHasKeys(value)) {\n      delete obj[key];\n    } else {\n      removeEmptyKey(value);\n    }\n  });\n  return obj;\n};\nexport var removeEmptyArraysFromObject = function removeEmptyArraysFromObject(obj) {\n  Object.keys(obj).forEach(function (key) {\n    var value = obj[key];\n\n    if (Array.isArray(value) && value.length === 0) {\n      delete obj[key];\n    }\n  });\n  return obj;\n};\nexport function addAbsolutePositions(hits, hitsPerPage, page) {\n  return hits.map(function (hit, index) {\n    return _objectSpread({}, hit, {\n      __position: hitsPerPage * page + index + 1\n    });\n  });\n}\nexport function addQueryID(hits, queryID) {\n  if (!queryID) {\n    return hits;\n  }\n\n  return hits.map(function (hit) {\n    return _objectSpread({}, hit, {\n      __queryID: queryID\n    });\n  });\n}\nexport function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return undefined;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return array[i];\n    }\n  }\n\n  return undefined;\n}\nexport function objectHasKeys(object) {\n  return object && Object.keys(object).length > 0;\n} // https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620\n\nexport function omit(source, excluded) {\n  if (source === null || source === undefined) {\n    return {};\n  }\n\n  var target = {};\n  var sourceKeys = Object.keys(source);\n\n  for (var i = 0; i < sourceKeys.length; i++) {\n    var _key = sourceKeys[i];\n\n    if (excluded.indexOf(_key) >= 0) {\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n\n    target[_key] = source[_key];\n  }\n\n  return target;\n}\n/**\n * Retrieve the value at a path of the object:\n *\n * @example\n * getPropertyByPath(\n *   { test: { this: { function: [{ now: { everyone: true } }] } } },\n *   'test.this.function[0].now.everyone'\n * ); // true\n *\n * getPropertyByPath(\n *   { test: { this: { function: [{ now: { everyone: true } }] } } },\n *   ['test', 'this', 'function', 0, 'now', 'everyone']\n * ); // true\n *\n * @param object Source object to query\n * @param path either an array of properties, or a string form of the properties, separated by .\n */\n\nexport var getPropertyByPath = function getPropertyByPath(object, path) {\n  return (Array.isArray(path) ? path : path.replace(/\\[(\\d+)]/g, '.$1').split('.')).reduce(function (current, key) {\n    return current ? current[key] : undefined;\n  }, object);\n};\nexport function getObjectType(object) {\n  return Object.prototype.toString.call(object).slice(8, -1);\n}","import { defer } from './utils';\nexport default function createWidgetsManager(onWidgetsUpdate) {\n  var widgets = []; // Is an update scheduled?\n\n  var scheduled = false; // The state manager's updates need to be batched since more than one\n  // component can register or unregister widgets during the same tick.\n\n  function scheduleUpdate() {\n    if (scheduled) {\n      return;\n    }\n\n    scheduled = true;\n    defer(function () {\n      scheduled = false;\n      onWidgetsUpdate();\n    });\n  }\n\n  return {\n    registerWidget: function registerWidget(widget) {\n      widgets.push(widget);\n      scheduleUpdate();\n      return function unregisterWidget() {\n        widgets.splice(widgets.indexOf(widget), 1);\n        scheduleUpdate();\n      };\n    },\n    update: scheduleUpdate,\n    getWidgets: function getWidgets() {\n      return widgets;\n    }\n  };\n}","import { getPropertyByPath } from './utils';\nexport var HIGHLIGHT_TAGS = {\n  highlightPreTag: \"<ais-highlight-0000000000>\",\n  highlightPostTag: \"</ais-highlight-0000000000>\"\n};\n/**\n * Parses an highlighted attribute into an array of objects with the string value, and\n * a boolean that indicated if this part is highlighted.\n *\n * @param {string} preTag - string used to identify the start of an highlighted value\n * @param {string} postTag - string used to identify the end of an highlighted value\n * @param {string} highlightedValue - highlighted attribute as returned by Algolia highlight feature\n * @return {object[]} - An array of {value: string, isHighlighted: boolean}.\n */\n\nfunction parseHighlightedAttribute(_ref) {\n  var preTag = _ref.preTag,\n      postTag = _ref.postTag,\n      _ref$highlightedValue = _ref.highlightedValue,\n      highlightedValue = _ref$highlightedValue === void 0 ? '' : _ref$highlightedValue;\n  var splitByPreTag = highlightedValue.split(preTag);\n  var firstValue = splitByPreTag.shift();\n  var elements = firstValue === '' ? [] : [{\n    value: firstValue,\n    isHighlighted: false\n  }];\n\n  if (postTag === preTag) {\n    var isHighlighted = true;\n    splitByPreTag.forEach(function (split) {\n      elements.push({\n        value: split,\n        isHighlighted: isHighlighted\n      });\n      isHighlighted = !isHighlighted;\n    });\n  } else {\n    splitByPreTag.forEach(function (split) {\n      var splitByPostTag = split.split(postTag);\n      elements.push({\n        value: splitByPostTag[0],\n        isHighlighted: true\n      });\n\n      if (splitByPostTag[1] !== '') {\n        elements.push({\n          value: splitByPostTag[1],\n          isHighlighted: false\n        });\n      }\n    });\n  }\n\n  return elements;\n}\n/**\n * Find an highlighted attribute given an `attribute` and an `highlightProperty`, parses it,\n * and provided an array of objects with the string value and a boolean if this\n * value is highlighted.\n *\n * In order to use this feature, highlight must be activated in the configuration of\n * the index. The `preTag` and `postTag` attributes are respectively highlightPreTag and\n * highlightPostTag in Algolia configuration.\n *\n * @param {string} preTag - string used to identify the start of an highlighted value\n * @param {string} postTag - string used to identify the end of an highlighted value\n * @param {string} highlightProperty - the property that contains the highlight structure in the results\n * @param {string} attribute - the highlighted attribute to look for\n * @param {object} hit - the actual hit returned by Algolia.\n * @return {object[]} - An array of {value: string, isHighlighted: boolean}.\n */\n\n\nexport function parseAlgoliaHit(_ref2) {\n  var _ref2$preTag = _ref2.preTag,\n      preTag = _ref2$preTag === void 0 ? '<em>' : _ref2$preTag,\n      _ref2$postTag = _ref2.postTag,\n      postTag = _ref2$postTag === void 0 ? '</em>' : _ref2$postTag,\n      highlightProperty = _ref2.highlightProperty,\n      attribute = _ref2.attribute,\n      hit = _ref2.hit;\n  if (!hit) throw new Error('`hit`, the matching record, must be provided');\n  var highlightObject = getPropertyByPath(hit[highlightProperty], attribute) || {};\n\n  if (Array.isArray(highlightObject)) {\n    return highlightObject.map(function (item) {\n      return parseHighlightedAttribute({\n        preTag: preTag,\n        postTag: postTag,\n        highlightedValue: item.value\n      });\n    });\n  }\n\n  return parseHighlightedAttribute({\n    preTag: preTag,\n    postTag: postTag,\n    highlightedValue: highlightObject.value\n  });\n}","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport { omit } from './utils';\nexport function getIndexId(context) {\n  return hasMultipleIndices(context) ? context.multiIndexContext.targetedIndex : context.ais.mainTargetedIndex;\n}\nexport function getResults(searchResults, context) {\n  if (searchResults.results) {\n    if (searchResults.results.hits) {\n      return searchResults.results;\n    }\n\n    var indexId = getIndexId(context);\n\n    if (searchResults.results[indexId]) {\n      return searchResults.results[indexId];\n    }\n  }\n\n  return null;\n}\nexport function hasMultipleIndices(context) {\n  return context && context.multiIndexContext;\n} // eslint-disable-next-line max-params\n\nexport function refineValue(searchState, nextRefinement, context, resetPage, namespace) {\n  if (hasMultipleIndices(context)) {\n    var indexId = getIndexId(context);\n    return namespace ? refineMultiIndexWithNamespace(searchState, nextRefinement, indexId, resetPage, namespace) : refineMultiIndex(searchState, nextRefinement, indexId, resetPage);\n  } else {\n    // When we have a multi index page with shared widgets we should also\n    // reset their page to 1 if the resetPage is provided. Otherwise the\n    // indices will always be reset\n    // see: https://github.com/algolia/react-instantsearch/issues/310\n    // see: https://github.com/algolia/react-instantsearch/issues/637\n    if (searchState.indices && resetPage) {\n      Object.keys(searchState.indices).forEach(function (targetedIndex) {\n        searchState = refineValue(searchState, {\n          page: 1\n        }, {\n          multiIndexContext: {\n            targetedIndex: targetedIndex\n          }\n        }, true, namespace);\n      });\n    }\n\n    return namespace ? refineSingleIndexWithNamespace(searchState, nextRefinement, resetPage, namespace) : refineSingleIndex(searchState, nextRefinement, resetPage);\n  }\n}\n\nfunction refineMultiIndex(searchState, nextRefinement, indexId, resetPage) {\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  var state = searchState.indices && searchState.indices[indexId] ? _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread({}, searchState.indices[indexId], nextRefinement, page))) : _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread({}, nextRefinement, page)));\n  return _objectSpread({}, searchState, {\n    indices: state\n  });\n}\n\nfunction refineSingleIndex(searchState, nextRefinement, resetPage) {\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  return _objectSpread({}, searchState, nextRefinement, page);\n} // eslint-disable-next-line max-params\n\n\nfunction refineMultiIndexWithNamespace(searchState, nextRefinement, indexId, resetPage, namespace) {\n  var _objectSpread4;\n\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  var state = searchState.indices && searchState.indices[indexId] ? _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread({}, searchState.indices[indexId], (_objectSpread4 = {}, _defineProperty(_objectSpread4, namespace, _objectSpread({}, searchState.indices[indexId][namespace], nextRefinement)), _defineProperty(_objectSpread4, \"page\", 1), _objectSpread4)))) : _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread(_defineProperty({}, namespace, nextRefinement), page)));\n  return _objectSpread({}, searchState, {\n    indices: state\n  });\n}\n\nfunction refineSingleIndexWithNamespace(searchState, nextRefinement, resetPage, namespace) {\n  var page = resetPage ? {\n    page: 1\n  } : undefined;\n  return _objectSpread({}, searchState, _defineProperty({}, namespace, _objectSpread({}, searchState[namespace], nextRefinement)), page);\n}\n\nfunction getNamespaceAndAttributeName(id) {\n  var parts = id.match(/^([^.]*)\\.(.*)/);\n  var namespace = parts && parts[1];\n  var attributeName = parts && parts[2];\n  return {\n    namespace: namespace,\n    attributeName: attributeName\n  };\n}\n\nfunction hasRefinements(_ref) {\n  var multiIndex = _ref.multiIndex,\n      indexId = _ref.indexId,\n      namespace = _ref.namespace,\n      attributeName = _ref.attributeName,\n      id = _ref.id,\n      searchState = _ref.searchState;\n\n  if (multiIndex && namespace) {\n    return searchState.indices && searchState.indices[indexId] && searchState.indices[indexId][namespace] && Object.hasOwnProperty.call(searchState.indices[indexId][namespace], attributeName);\n  }\n\n  if (multiIndex) {\n    return searchState.indices && searchState.indices[indexId] && Object.hasOwnProperty.call(searchState.indices[indexId], id);\n  }\n\n  if (namespace) {\n    return searchState[namespace] && Object.hasOwnProperty.call(searchState[namespace], attributeName);\n  }\n\n  return Object.hasOwnProperty.call(searchState, id);\n}\n\nfunction getRefinements(_ref2) {\n  var multiIndex = _ref2.multiIndex,\n      indexId = _ref2.indexId,\n      namespace = _ref2.namespace,\n      attributeName = _ref2.attributeName,\n      id = _ref2.id,\n      searchState = _ref2.searchState;\n\n  if (multiIndex && namespace) {\n    return searchState.indices[indexId][namespace][attributeName];\n  }\n\n  if (multiIndex) {\n    return searchState.indices[indexId][id];\n  }\n\n  if (namespace) {\n    return searchState[namespace][attributeName];\n  }\n\n  return searchState[id];\n}\n\nexport function getCurrentRefinementValue(props, searchState, context, id, defaultValue) {\n  var indexId = getIndexId(context);\n\n  var _getNamespaceAndAttri = getNamespaceAndAttributeName(id),\n      namespace = _getNamespaceAndAttri.namespace,\n      attributeName = _getNamespaceAndAttri.attributeName;\n\n  var multiIndex = hasMultipleIndices(context);\n  var args = {\n    multiIndex: multiIndex,\n    indexId: indexId,\n    namespace: namespace,\n    attributeName: attributeName,\n    id: id,\n    searchState: searchState\n  };\n  var hasRefinementsValue = hasRefinements(args);\n\n  if (hasRefinementsValue) {\n    return getRefinements(args);\n  }\n\n  if (props.defaultRefinement) {\n    return props.defaultRefinement;\n  }\n\n  return defaultValue;\n}\nexport function cleanUpValue(searchState, context, id) {\n  var indexId = getIndexId(context);\n\n  var _getNamespaceAndAttri2 = getNamespaceAndAttributeName(id),\n      namespace = _getNamespaceAndAttri2.namespace,\n      attributeName = _getNamespaceAndAttri2.attributeName;\n\n  if (hasMultipleIndices(context) && Boolean(searchState.indices)) {\n    return cleanUpValueWithMultiIndex({\n      attribute: attributeName,\n      searchState: searchState,\n      indexId: indexId,\n      id: id,\n      namespace: namespace\n    });\n  }\n\n  return cleanUpValueWithSingleIndex({\n    attribute: attributeName,\n    searchState: searchState,\n    id: id,\n    namespace: namespace\n  });\n}\n\nfunction cleanUpValueWithSingleIndex(_ref3) {\n  var searchState = _ref3.searchState,\n      id = _ref3.id,\n      namespace = _ref3.namespace,\n      attribute = _ref3.attribute;\n\n  if (namespace) {\n    return _objectSpread({}, searchState, _defineProperty({}, namespace, omit(searchState[namespace], [attribute])));\n  }\n\n  return omit(searchState, [id]);\n}\n\nfunction cleanUpValueWithMultiIndex(_ref4) {\n  var searchState = _ref4.searchState,\n      indexId = _ref4.indexId,\n      id = _ref4.id,\n      namespace = _ref4.namespace,\n      attribute = _ref4.attribute;\n  var indexSearchState = searchState.indices[indexId];\n\n  if (namespace && indexSearchState) {\n    return _objectSpread({}, searchState, {\n      indices: _objectSpread({}, searchState.indices, _defineProperty({}, indexId, _objectSpread({}, indexSearchState, _defineProperty({}, namespace, omit(indexSearchState[namespace], [attribute])))))\n    });\n  }\n\n  if (indexSearchState) {\n    return _objectSpread({}, searchState, {\n      indices: _objectSpread({}, searchState.indices, _defineProperty({}, indexId, omit(indexSearchState, [id])))\n    });\n  }\n\n  return searchState;\n}","import \"core-js/modules/es.array.reduce.js\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport algoliasearchHelper from 'algoliasearch-helper';\nimport createWidgetsManager from './createWidgetsManager';\nimport createStore from './createStore';\nimport { HIGHLIGHT_TAGS } from './highlight';\nimport { hasMultipleIndices } from './indexUtils';\nimport { version as ReactVersion } from 'react';\nimport version from './version';\n\nfunction addAlgoliaAgents(searchClient) {\n  if (typeof searchClient.addAlgoliaAgent === 'function') {\n    searchClient.addAlgoliaAgent(\"react (\".concat(ReactVersion, \")\"));\n    searchClient.addAlgoliaAgent(\"react-instantsearch (\".concat(version, \")\"));\n  }\n}\n\nvar isMultiIndexContext = function isMultiIndexContext(widget) {\n  return hasMultipleIndices({\n    ais: widget.props.contextValue,\n    multiIndexContext: widget.props.indexContextValue\n  });\n};\n\nvar isTargetedIndexEqualIndex = function isTargetedIndexEqualIndex(widget, indexId) {\n  return widget.props.indexContextValue.targetedIndex === indexId;\n}; // Relying on the `indexId` is a bit brittle to detect the `Index` widget.\n// Since it's a class we could rely on `instanceof` or similar. We never\n// had an issue though. Works for now.\n\n\nvar isIndexWidget = function isIndexWidget(widget) {\n  return Boolean(widget.props.indexId);\n};\n\nvar isIndexWidgetEqualIndex = function isIndexWidgetEqualIndex(widget, indexId) {\n  return widget.props.indexId === indexId;\n};\n\nvar sortIndexWidgetsFirst = function sortIndexWidgetsFirst(firstWidget, secondWidget) {\n  var isFirstWidgetIndex = isIndexWidget(firstWidget);\n  var isSecondWidgetIndex = isIndexWidget(secondWidget);\n\n  if (isFirstWidgetIndex && !isSecondWidgetIndex) {\n    return -1;\n  }\n\n  if (!isFirstWidgetIndex && isSecondWidgetIndex) {\n    return 1;\n  }\n\n  return 0;\n}; // This function is copied from the algoliasearch v4 API Client. If modified,\n// consider updating it also in `serializeQueryParameters` from `@algolia/transporter`.\n\n\nfunction serializeQueryParameters(parameters) {\n  var isObjectOrArray = function isObjectOrArray(value) {\n    return Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === '[object Array]';\n  };\n\n  var encode = function encode(format) {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    var i = 0;\n    return format.replace(/%s/g, function () {\n      return encodeURIComponent(args[i++]);\n    });\n  };\n\n  return Object.keys(parameters).map(function (key) {\n    return encode('%s=%s', key, isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key]);\n  }).join('&');\n}\n/**\n * Creates a new instance of the InstantSearchManager which controls the widgets and\n * trigger the search when the widgets are updated.\n * @param {string} indexName - the main index name\n * @param {object} initialState - initial widget state\n * @param {object} SearchParameters - optional additional parameters to send to the algolia API\n * @param {number} stalledSearchDelay - time (in ms) after the search is stalled\n * @return {InstantSearchManager} a new instance of InstantSearchManager\n */\n\n\nexport default function createInstantSearchManager(_ref) {\n  var indexName = _ref.indexName,\n      _ref$initialState = _ref.initialState,\n      initialState = _ref$initialState === void 0 ? {} : _ref$initialState,\n      searchClient = _ref.searchClient,\n      resultsState = _ref.resultsState,\n      stalledSearchDelay = _ref.stalledSearchDelay;\n  var helper = algoliasearchHelper(searchClient, indexName, _objectSpread({}, HIGHLIGHT_TAGS));\n  addAlgoliaAgents(searchClient);\n  helper.on('search', handleNewSearch).on('result', handleSearchSuccess({\n    indexId: indexName\n  })).on('error', handleSearchError);\n  var skip = false;\n  var stalledSearchTimer = null;\n  var initialSearchParameters = helper.state;\n  var widgetsManager = createWidgetsManager(onWidgetsUpdate);\n  hydrateSearchClient(searchClient, resultsState);\n  var store = createStore({\n    widgets: initialState,\n    metadata: hydrateMetadata(resultsState),\n    results: hydrateResultsState(resultsState),\n    error: null,\n    searching: false,\n    isSearchStalled: true,\n    searchingForFacetValues: false\n  });\n\n  function skipSearch() {\n    skip = true;\n  }\n\n  function updateClient(client) {\n    addAlgoliaAgents(client);\n    helper.setClient(client);\n    search();\n  }\n\n  function clearCache() {\n    helper.clearCache();\n    search();\n  }\n\n  function getMetadata(state) {\n    return widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getMetadata);\n    }).map(function (widget) {\n      return widget.getMetadata(state);\n    });\n  }\n\n  function getSearchParameters() {\n    var sharedParameters = widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getSearchParameters);\n    }).filter(function (widget) {\n      return !isMultiIndexContext(widget) && !isIndexWidget(widget);\n    }).reduce(function (res, widget) {\n      return widget.getSearchParameters(res);\n    }, initialSearchParameters);\n    var mainParameters = widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getSearchParameters);\n    }).filter(function (widget) {\n      var targetedIndexEqualMainIndex = isMultiIndexContext(widget) && isTargetedIndexEqualIndex(widget, indexName);\n      var subIndexEqualMainIndex = isIndexWidget(widget) && isIndexWidgetEqualIndex(widget, indexName);\n      return targetedIndexEqualMainIndex || subIndexEqualMainIndex;\n    }) // We have to sort the `Index` widgets first so the `index` parameter\n    // is correctly set in the `reduce` function for the following widgets\n    .sort(sortIndexWidgetsFirst).reduce(function (res, widget) {\n      return widget.getSearchParameters(res);\n    }, sharedParameters);\n    var derivedIndices = widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.getSearchParameters);\n    }).filter(function (widget) {\n      var targetedIndexNotEqualMainIndex = isMultiIndexContext(widget) && !isTargetedIndexEqualIndex(widget, indexName);\n      var subIndexNotEqualMainIndex = isIndexWidget(widget) && !isIndexWidgetEqualIndex(widget, indexName);\n      return targetedIndexNotEqualMainIndex || subIndexNotEqualMainIndex;\n    }) // We have to sort the `Index` widgets first so the `index` parameter\n    // is correctly set in the `reduce` function for the following widgets\n    .sort(sortIndexWidgetsFirst).reduce(function (indices, widget) {\n      var indexId = isMultiIndexContext(widget) ? widget.props.indexContextValue.targetedIndex : widget.props.indexId;\n      var widgets = indices[indexId] || [];\n      return _objectSpread({}, indices, _defineProperty({}, indexId, widgets.concat(widget)));\n    }, {});\n    var derivedParameters = Object.keys(derivedIndices).map(function (indexId) {\n      return {\n        parameters: derivedIndices[indexId].reduce(function (res, widget) {\n          return widget.getSearchParameters(res);\n        }, sharedParameters),\n        indexId: indexId\n      };\n    });\n    return {\n      mainParameters: mainParameters,\n      derivedParameters: derivedParameters\n    };\n  }\n\n  function search() {\n    if (!skip) {\n      var _getSearchParameters = getSearchParameters(helper.state),\n          mainParameters = _getSearchParameters.mainParameters,\n          derivedParameters = _getSearchParameters.derivedParameters; // We have to call `slice` because the method `detach` on the derived\n      // helpers mutates the value `derivedHelpers`. The `forEach` loop does\n      // not iterate on each value and we're not able to correctly clear the\n      // previous derived helpers (memory leak + useless requests).\n\n\n      helper.derivedHelpers.slice().forEach(function (derivedHelper) {\n        // Since we detach the derived helpers on **every** new search they\n        // won't receive intermediate results in case of a stalled search.\n        // Only the last result is dispatched by the derived helper because\n        // they are not detached yet:\n        //\n        // - a -> main helper receives results\n        // - ap -> main helper receives results\n        // - app -> main helper + derived helpers receive results\n        //\n        // The quick fix is to avoid to detach them on search but only once they\n        // received the results. But it means that in case of a stalled search\n        // all the derived helpers not detached yet register a new search inside\n        // the helper. The number grows fast in case of a bad network and it's\n        // not deterministic.\n        derivedHelper.detach();\n      });\n      derivedParameters.forEach(function (_ref2) {\n        var indexId = _ref2.indexId,\n            parameters = _ref2.parameters;\n        var derivedHelper = helper.derive(function () {\n          return parameters;\n        });\n        derivedHelper.on('result', handleSearchSuccess({\n          indexId: indexId\n        })).on('error', handleSearchError);\n      });\n      helper.setState(mainParameters);\n      helper.search();\n    }\n  }\n\n  function handleSearchSuccess(_ref3) {\n    var indexId = _ref3.indexId;\n    return function (event) {\n      var state = store.getState();\n      var isDerivedHelpersEmpty = !helper.derivedHelpers.length;\n      var results = state.results ? state.results : {}; // Switching from mono index to multi index and vice versa must reset the\n      // results to an empty object, otherwise we keep reference of stalled and\n      // unused results.\n\n      results = !isDerivedHelpersEmpty && results.getFacetByName ? {} : results;\n\n      if (!isDerivedHelpersEmpty) {\n        results = _objectSpread({}, results, _defineProperty({}, indexId, event.results));\n      } else {\n        results = event.results;\n      }\n\n      var currentState = store.getState();\n      var nextIsSearchStalled = currentState.isSearchStalled;\n\n      if (!helper.hasPendingRequests()) {\n        clearTimeout(stalledSearchTimer);\n        stalledSearchTimer = null;\n        nextIsSearchStalled = false;\n      }\n\n      var resultsFacetValues = currentState.resultsFacetValues,\n          partialState = _objectWithoutProperties(currentState, [\"resultsFacetValues\"]);\n\n      store.setState(_objectSpread({}, partialState, {\n        results: results,\n        isSearchStalled: nextIsSearchStalled,\n        searching: false,\n        error: null\n      }));\n    };\n  }\n\n  function handleSearchError(_ref4) {\n    var error = _ref4.error;\n    var currentState = store.getState();\n    var nextIsSearchStalled = currentState.isSearchStalled;\n\n    if (!helper.hasPendingRequests()) {\n      clearTimeout(stalledSearchTimer);\n      nextIsSearchStalled = false;\n    }\n\n    var resultsFacetValues = currentState.resultsFacetValues,\n        partialState = _objectWithoutProperties(currentState, [\"resultsFacetValues\"]);\n\n    store.setState(_objectSpread({}, partialState, {\n      isSearchStalled: nextIsSearchStalled,\n      error: error,\n      searching: false\n    }));\n  }\n\n  function handleNewSearch() {\n    if (!stalledSearchTimer) {\n      stalledSearchTimer = setTimeout(function () {\n        var _store$getState = store.getState(),\n            resultsFacetValues = _store$getState.resultsFacetValues,\n            partialState = _objectWithoutProperties(_store$getState, [\"resultsFacetValues\"]);\n\n        store.setState(_objectSpread({}, partialState, {\n          isSearchStalled: true\n        }));\n      }, stalledSearchDelay);\n    }\n  }\n\n  function hydrateSearchClient(client, results) {\n    if (!results) {\n      return;\n    } // Disable cache hydration on:\n    // - Algoliasearch API Client < v4 with cache disabled\n    // - Third party clients (detected by the `addAlgoliaAgent` function missing)\n\n\n    if ((!client.transporter || client._cacheHydrated) && (!client._useCache || typeof client.addAlgoliaAgent !== 'function')) {\n      return;\n    } // Algoliasearch API Client >= v4\n    // To hydrate the client we need to populate the cache with the data from\n    // the server (done in `hydrateSearchClientWithMultiIndexRequest` or\n    // `hydrateSearchClientWithSingleIndexRequest`). But since there is no way\n    // for us to compute the key the same way as `algoliasearch-client` we need\n    // to populate it on a custom key and override the `search` method to\n    // search on it first.\n\n\n    if (client.transporter && !client._cacheHydrated) {\n      client._cacheHydrated = true;\n      var baseMethod = client.search;\n\n      client.search = function (requests) {\n        for (var _len2 = arguments.length, methodArgs = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n          methodArgs[_key2 - 1] = arguments[_key2];\n        }\n\n        var requestsWithSerializedParams = requests.map(function (request) {\n          return _objectSpread({}, request, {\n            params: serializeQueryParameters(request.params)\n          });\n        });\n        return client.transporter.responsesCache.get({\n          method: 'search',\n          args: [requestsWithSerializedParams].concat(methodArgs)\n        }, function () {\n          return baseMethod.apply(void 0, [requests].concat(methodArgs));\n        });\n      };\n    }\n\n    if (Array.isArray(results.results)) {\n      hydrateSearchClientWithMultiIndexRequest(client, results.results);\n      return;\n    }\n\n    hydrateSearchClientWithSingleIndexRequest(client, results);\n  }\n\n  function hydrateSearchClientWithMultiIndexRequest(client, results) {\n    // Algoliasearch API Client >= v4\n    // Populate the cache with the data from the server\n    if (client.transporter) {\n      client.transporter.responsesCache.set({\n        method: 'search',\n        args: [results.reduce(function (acc, result) {\n          return acc.concat(result.rawResults.map(function (request) {\n            return {\n              indexName: request.index,\n              params: request.params\n            };\n          }));\n        }, [])]\n      }, {\n        results: results.reduce(function (acc, result) {\n          return acc.concat(result.rawResults);\n        }, [])\n      });\n      return;\n    } // Algoliasearch API Client < v4\n    // Prior to client v4 we didn't have a proper API to hydrate the client\n    // cache from the outside. The following code populates the cache with\n    // a single-index result. You can find more information about the\n    // computation of the key inside the client (see link below).\n    // https://github.com/algolia/algoliasearch-client-javascript/blob/c27e89ff92b2a854ae6f40dc524bffe0f0cbc169/src/AlgoliaSearchCore.js#L232-L240\n\n\n    var key = \"/1/indexes/*/queries_body_\".concat(JSON.stringify({\n      requests: results.reduce(function (acc, result) {\n        return acc.concat(result.rawResults.map(function (request) {\n          return {\n            indexName: request.index,\n            params: request.params\n          };\n        }));\n      }, [])\n    }));\n    client.cache = _objectSpread({}, client.cache, _defineProperty({}, key, JSON.stringify({\n      results: results.reduce(function (acc, result) {\n        return acc.concat(result.rawResults);\n      }, [])\n    })));\n  }\n\n  function hydrateSearchClientWithSingleIndexRequest(client, results) {\n    // Algoliasearch API Client >= v4\n    // Populate the cache with the data from the server\n    if (client.transporter) {\n      client.transporter.responsesCache.set({\n        method: 'search',\n        args: [results.rawResults.map(function (request) {\n          return {\n            indexName: request.index,\n            params: request.params\n          };\n        })]\n      }, {\n        results: results.rawResults\n      });\n      return;\n    } // Algoliasearch API Client < v4\n    // Prior to client v4 we didn't have a proper API to hydrate the client\n    // cache from the outside. The following code populates the cache with\n    // a single-index result. You can find more information about the\n    // computation of the key inside the client (see link below).\n    // https://github.com/algolia/algoliasearch-client-javascript/blob/c27e89ff92b2a854ae6f40dc524bffe0f0cbc169/src/AlgoliaSearchCore.js#L232-L240\n\n\n    var key = \"/1/indexes/*/queries_body_\".concat(JSON.stringify({\n      requests: results.rawResults.map(function (request) {\n        return {\n          indexName: request.index,\n          params: request.params\n        };\n      })\n    }));\n    client.cache = _objectSpread({}, client.cache, _defineProperty({}, key, JSON.stringify({\n      results: results.rawResults\n    })));\n  }\n\n  function hydrateResultsState(results) {\n    if (!results) {\n      return null;\n    }\n\n    if (Array.isArray(results.results)) {\n      return results.results.reduce(function (acc, result) {\n        return _objectSpread({}, acc, _defineProperty({}, result._internalIndexId, new algoliasearchHelper.SearchResults(new algoliasearchHelper.SearchParameters(result.state), result.rawResults)));\n      }, {});\n    }\n\n    return new algoliasearchHelper.SearchResults(new algoliasearchHelper.SearchParameters(results.state), results.rawResults);\n  } // Called whenever a widget has been rendered with new props.\n\n\n  function onWidgetsUpdate() {\n    var metadata = getMetadata(store.getState().widgets);\n    store.setState(_objectSpread({}, store.getState(), {\n      metadata: metadata,\n      searching: true\n    })); // Since the `getSearchParameters` method of widgets also depends on props,\n    // the result search parameters might have changed.\n\n    search();\n  }\n\n  function transitionState(nextSearchState) {\n    var searchState = store.getState().widgets;\n    return widgetsManager.getWidgets().filter(function (widget) {\n      return Boolean(widget.transitionState);\n    }).reduce(function (res, widget) {\n      return widget.transitionState(searchState, res);\n    }, nextSearchState);\n  }\n\n  function onExternalStateUpdate(nextSearchState) {\n    var metadata = getMetadata(nextSearchState);\n    store.setState(_objectSpread({}, store.getState(), {\n      widgets: nextSearchState,\n      metadata: metadata,\n      searching: true\n    }));\n    search();\n  }\n\n  function onSearchForFacetValues(_ref5) {\n    var facetName = _ref5.facetName,\n        query = _ref5.query,\n        _ref5$maxFacetHits = _ref5.maxFacetHits,\n        maxFacetHits = _ref5$maxFacetHits === void 0 ? 10 : _ref5$maxFacetHits; // The values 1, 100 are the min / max values that the engine accepts.\n    // see: https://www.algolia.com/doc/api-reference/api-parameters/maxFacetHits\n\n    var maxFacetHitsWithinRange = Math.max(1, Math.min(maxFacetHits, 100));\n    store.setState(_objectSpread({}, store.getState(), {\n      searchingForFacetValues: true\n    }));\n    helper.searchForFacetValues(facetName, query, maxFacetHitsWithinRange).then(function (content) {\n      var _objectSpread7;\n\n      store.setState(_objectSpread({}, store.getState(), {\n        error: null,\n        searchingForFacetValues: false,\n        resultsFacetValues: _objectSpread({}, store.getState().resultsFacetValues, (_objectSpread7 = {}, _defineProperty(_objectSpread7, facetName, content.facetHits), _defineProperty(_objectSpread7, \"query\", query), _objectSpread7))\n      }));\n    }, function (error) {\n      store.setState(_objectSpread({}, store.getState(), {\n        searchingForFacetValues: false,\n        error: error\n      }));\n    }).catch(function (error) {\n      // Since setState is synchronous, any error that occurs in the render of a\n      // component will be swallowed by this promise.\n      // This is a trick to make the error show up correctly in the console.\n      // See http://stackoverflow.com/a/30741722/969302\n      setTimeout(function () {\n        throw error;\n      });\n    });\n  }\n\n  function updateIndex(newIndex) {\n    initialSearchParameters = initialSearchParameters.setIndex(newIndex); // No need to trigger a new search here as the widgets will also update and trigger it if needed.\n  }\n\n  function getWidgetsIds() {\n    return store.getState().metadata.reduce(function (res, meta) {\n      return typeof meta.id !== 'undefined' ? res.concat(meta.id) : res;\n    }, []);\n  }\n\n  return {\n    store: store,\n    widgetsManager: widgetsManager,\n    getWidgetsIds: getWidgetsIds,\n    getSearchParameters: getSearchParameters,\n    onSearchForFacetValues: onSearchForFacetValues,\n    onExternalStateUpdate: onExternalStateUpdate,\n    transitionState: transitionState,\n    updateClient: updateClient,\n    updateIndex: updateIndex,\n    clearCache: clearCache,\n    skipSearch: skipSearch\n  };\n}\n\nfunction hydrateMetadata(resultsState) {\n  if (!resultsState) {\n    return [];\n  } // add a value noop, which gets replaced once the widgets are mounted\n\n\n  return resultsState.metadata.map(function (datum) {\n    return _objectSpread({\n      value: function value() {}\n    }, datum, {\n      items: datum.items && datum.items.map(function (item) {\n        return _objectSpread({\n          value: function value() {}\n        }, item, {\n          items: item.items && item.items.map(function (nestedItem) {\n            return _objectSpread({\n              value: function value() {}\n            }, nestedItem);\n          })\n        });\n      })\n    });\n  });\n}","export default '6.8.3';","export default function createStore(initialState) {\n  var state = initialState;\n  var listeners = [];\n  return {\n    getState: function getState() {\n      return state;\n    },\n    setState: function setState(nextState) {\n      state = nextState;\n      listeners.forEach(function (listener) {\n        return listener();\n      });\n    },\n    subscribe: function subscribe(listener) {\n      listeners.push(listener);\n      return function unsubscribe() {\n        listeners.splice(listeners.indexOf(listener), 1);\n      };\n    }\n  };\n}","import { createContext } from 'react';\n\nvar _createContext = createContext({\n  onInternalStateUpdate: function onInternalStateUpdate() {\n    return undefined;\n  },\n  createHrefForState: function createHrefForState() {\n    return '#';\n  },\n  onSearchForFacetValues: function onSearchForFacetValues() {\n    return undefined;\n  },\n  onSearchStateChange: function onSearchStateChange() {\n    return undefined;\n  },\n  onSearchParameters: function onSearchParameters() {\n    return undefined;\n  },\n  store: {},\n  widgetsManager: {},\n  mainTargetedIndex: ''\n}),\n    InstantSearchConsumer = _createContext.Consumer,\n    InstantSearchProvider = _createContext.Provider;\n\nexport { InstantSearchConsumer, InstantSearchProvider };\n\nvar _createContext2 = createContext(undefined),\n    IndexConsumer = _createContext2.Consumer,\n    IndexProvider = _createContext2.Provider;\n\nexport { IndexConsumer, IndexProvider };","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport React, { Component, Children } from 'react';\nimport isEqual from 'react-fast-compare';\nimport PropTypes from 'prop-types';\nimport createInstantSearchManager from '../core/createInstantSearchManager';\nimport { InstantSearchProvider } from '../core/context';\n\nfunction isControlled(props) {\n  return Boolean(props.searchState);\n}\n/**\n * @description\n * `<InstantSearch>` is the root component of all React InstantSearch implementations.\n * It provides all the connected components (aka widgets) a means to interact\n * with the searchState.\n * @kind widget\n * @name <InstantSearch>\n * @requirements You will need to have an Algolia account to be able to use this widget.\n * [Create one now](https://www.algolia.com/users/sign_up).\n * @propType {string} indexName - Main index in which to search.\n * @propType {boolean} [refresh=false] - Flag to activate when the cache needs to be cleared so that the front-end is updated when a change occurs in the index.\n * @propType {object} [searchClient] - Provide a custom search client.\n * @propType {func} [onSearchStateChange] - Function to be called everytime a new search is done. Useful for [URL Routing](guide/Routing.html).\n * @propType {object} [searchState] - Object to inject some search state. Switches the InstantSearch component in controlled mode. Useful for [URL Routing](guide/Routing.html).\n * @propType {func} [createURL] - Function to call when creating links, useful for [URL Routing](guide/Routing.html).\n * @propType {SearchResults|SearchResults[]} [resultsState] - Use this to inject the results that will be used at first rendering. Those results are found by using the `findResultsState` function. Useful for [Server Side Rendering](guide/Server-side_rendering.html).\n * @propType {number} [stalledSearchDelay=200] - The amount of time before considering that the search takes too much time. The time is expressed in milliseconds.\n * @propType {{ Root: string|function, props: object }} [root] - Use this to customize the root element. Default value: `{ Root: 'div' }`\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, SearchBox, Hits } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <SearchBox />\n *     <Hits />\n *   </InstantSearch>\n * );\n */\n\n\nvar InstantSearch = /*#__PURE__*/function (_Component) {\n  _inherits(InstantSearch, _Component);\n\n  _createClass(InstantSearch, null, [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      var nextIsControlled = isControlled(nextProps);\n      var previousSearchState = prevState.instantSearchManager.store.getState().widgets;\n      var nextSearchState = nextProps.searchState;\n\n      if (nextIsControlled && !isEqual(previousSearchState, nextSearchState)) {\n        prevState.instantSearchManager.onExternalStateUpdate(nextProps.searchState);\n      }\n\n      return {\n        isControlled: nextIsControlled,\n        contextValue: _objectSpread({}, prevState.contextValue, {\n          mainTargetedIndex: nextProps.indexName\n        })\n      };\n    }\n  }]);\n\n  function InstantSearch(props) {\n    var _this;\n\n    _classCallCheck(this, InstantSearch);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(InstantSearch).call(this, props));\n\n    _defineProperty(_assertThisInitialized(_this), \"isUnmounting\", false);\n\n    var instantSearchManager = createInstantSearchManager({\n      indexName: _this.props.indexName,\n      searchClient: _this.props.searchClient,\n      initialState: _this.props.searchState || {},\n      resultsState: _this.props.resultsState,\n      stalledSearchDelay: _this.props.stalledSearchDelay\n    });\n    var contextValue = {\n      store: instantSearchManager.store,\n      widgetsManager: instantSearchManager.widgetsManager,\n      mainTargetedIndex: _this.props.indexName,\n      onInternalStateUpdate: _this.onWidgetsInternalStateUpdate.bind(_assertThisInitialized(_this)),\n      createHrefForState: _this.createHrefForState.bind(_assertThisInitialized(_this)),\n      onSearchForFacetValues: _this.onSearchForFacetValues.bind(_assertThisInitialized(_this)),\n      onSearchStateChange: _this.onSearchStateChange.bind(_assertThisInitialized(_this)),\n      onSearchParameters: _this.onSearchParameters.bind(_assertThisInitialized(_this))\n    };\n    _this.state = {\n      isControlled: isControlled(_this.props),\n      instantSearchManager: instantSearchManager,\n      contextValue: contextValue\n    };\n    return _this;\n  }\n\n  _createClass(InstantSearch, [{\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps) {\n      var prevIsControlled = isControlled(prevProps);\n\n      if (prevIsControlled && !this.state.isControlled) {\n        throw new Error(\"You can't switch <InstantSearch> from being controlled to uncontrolled\");\n      }\n\n      if (!prevIsControlled && this.state.isControlled) {\n        throw new Error(\"You can't switch <InstantSearch> from being uncontrolled to controlled\");\n      }\n\n      if (this.props.refresh !== prevProps.refresh && this.props.refresh) {\n        this.state.instantSearchManager.clearCache();\n      }\n\n      if (prevProps.indexName !== this.props.indexName) {\n        this.state.instantSearchManager.updateIndex(this.props.indexName);\n      }\n\n      if (prevProps.searchClient !== this.props.searchClient) {\n        this.state.instantSearchManager.updateClient(this.props.searchClient);\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this.isUnmounting = true;\n      this.state.instantSearchManager.skipSearch();\n    }\n  }, {\n    key: \"createHrefForState\",\n    value: function createHrefForState(searchState) {\n      searchState = this.state.instantSearchManager.transitionState(searchState);\n      return this.state.isControlled && this.props.createURL ? this.props.createURL(searchState, this.getKnownKeys()) : '#';\n    }\n  }, {\n    key: \"onWidgetsInternalStateUpdate\",\n    value: function onWidgetsInternalStateUpdate(searchState) {\n      searchState = this.state.instantSearchManager.transitionState(searchState);\n      this.onSearchStateChange(searchState);\n\n      if (!this.state.isControlled) {\n        this.state.instantSearchManager.onExternalStateUpdate(searchState);\n      }\n    }\n  }, {\n    key: \"onSearchStateChange\",\n    value: function onSearchStateChange(searchState) {\n      if (this.props.onSearchStateChange && !this.isUnmounting) {\n        this.props.onSearchStateChange(searchState);\n      }\n    }\n  }, {\n    key: \"onSearchParameters\",\n    value: function onSearchParameters(getSearchParameters, context, props, getMetadata) {\n      if (this.props.onSearchParameters) {\n        var _searchState = this.props.searchState ? this.props.searchState : {};\n\n        this.props.onSearchParameters(getSearchParameters, context, props, _searchState);\n      }\n\n      if (this.props.widgetsCollector) {\n        var _searchState2 = this.props.searchState ? this.props.searchState : {};\n\n        this.props.widgetsCollector({\n          getSearchParameters: getSearchParameters,\n          getMetadata: getMetadata,\n          context: context,\n          props: props,\n          searchState: _searchState2\n        });\n      }\n    }\n  }, {\n    key: \"onSearchForFacetValues\",\n    value: function onSearchForFacetValues(searchState) {\n      this.state.instantSearchManager.onSearchForFacetValues(searchState);\n    }\n  }, {\n    key: \"getKnownKeys\",\n    value: function getKnownKeys() {\n      return this.state.instantSearchManager.getWidgetsIds();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      if (Children.count(this.props.children) === 0) {\n        return null;\n      }\n\n      return React.createElement(InstantSearchProvider, {\n        value: this.state.contextValue\n      }, this.props.children);\n    }\n  }]);\n\n  return InstantSearch;\n}(Component);\n\n_defineProperty(InstantSearch, \"defaultProps\", {\n  stalledSearchDelay: 200,\n  refresh: false\n});\n\n_defineProperty(InstantSearch, \"propTypes\", {\n  // @TODO: These props are currently constant.\n  indexName: PropTypes.string.isRequired,\n  searchClient: PropTypes.shape({\n    search: PropTypes.func.isRequired,\n    searchForFacetValues: PropTypes.func,\n    addAlgoliaAgent: PropTypes.func,\n    clearCache: PropTypes.func\n  }).isRequired,\n  createURL: PropTypes.func,\n  refresh: PropTypes.bool,\n  searchState: PropTypes.object,\n  onSearchStateChange: PropTypes.func,\n  onSearchParameters: PropTypes.func,\n  widgetsCollector: PropTypes.func,\n  resultsState: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),\n  children: PropTypes.node,\n  stalledSearchDelay: PropTypes.number\n});\n\nexport default InstantSearch;","export default function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport React, { Component } from 'react';\nimport isEqual from 'react-fast-compare';\nimport { shallowEqual, getDisplayName, removeEmptyKey } from './utils';\nimport { InstantSearchConsumer, IndexConsumer } from './context';\n/**\n * Connectors are the HOC used to transform React components\n * into InstantSearch widgets.\n * In order to simplify the construction of such connectors\n * `createConnector` takes a description and transform it into\n * a connector.\n * @param {ConnectorDescription} connectorDesc the description of the connector\n * @return {Connector} a function that wraps a component into\n * an instantsearch connected one.\n */\n\nexport function createConnectorWithoutContext(connectorDesc) {\n  if (!connectorDesc.displayName) {\n    throw new Error('`createConnector` requires you to provide a `displayName` property.');\n  }\n\n  var isWidget = typeof connectorDesc.getSearchParameters === 'function' || typeof connectorDesc.getMetadata === 'function' || typeof connectorDesc.transitionState === 'function';\n  return function (Composed) {\n    var Connector = /*#__PURE__*/function (_Component) {\n      _inherits(Connector, _Component);\n\n      function Connector(props) {\n        var _this;\n\n        _classCallCheck(this, Connector);\n\n        _this = _possibleConstructorReturn(this, _getPrototypeOf(Connector).call(this, props));\n\n        _defineProperty(_assertThisInitialized(_this), \"unsubscribe\", void 0);\n\n        _defineProperty(_assertThisInitialized(_this), \"unregisterWidget\", void 0);\n\n        _defineProperty(_assertThisInitialized(_this), \"isUnmounting\", false);\n\n        _defineProperty(_assertThisInitialized(_this), \"state\", {\n          providedProps: _this.getProvidedProps(_this.props)\n        });\n\n        _defineProperty(_assertThisInitialized(_this), \"refine\", function () {\n          var _ref;\n\n          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n            args[_key] = arguments[_key];\n          }\n\n          _this.props.contextValue.onInternalStateUpdate( // refine will always be defined here because the prop is only given conditionally\n          (_ref = connectorDesc.refine).call.apply(_ref, [_assertThisInitialized(_this), _this.props, _this.props.contextValue.store.getState().widgets].concat(args)));\n        });\n\n        _defineProperty(_assertThisInitialized(_this), \"createURL\", function () {\n          var _ref2;\n\n          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n            args[_key2] = arguments[_key2];\n          }\n\n          return _this.props.contextValue.createHrefForState( // refine will always be defined here because the prop is only given conditionally\n          (_ref2 = connectorDesc.refine).call.apply(_ref2, [_assertThisInitialized(_this), _this.props, _this.props.contextValue.store.getState().widgets].concat(args)));\n        });\n\n        _defineProperty(_assertThisInitialized(_this), \"searchForFacetValues\", function () {\n          var _ref3;\n\n          for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n            args[_key3] = arguments[_key3];\n          }\n\n          _this.props.contextValue.onSearchForFacetValues( // searchForFacetValues will always be defined here because the prop is only given conditionally\n          (_ref3 = connectorDesc.searchForFacetValues).call.apply(_ref3, [_assertThisInitialized(_this), _this.props, _this.props.contextValue.store.getState().widgets].concat(args)));\n        });\n\n        if (connectorDesc.getSearchParameters) {\n          _this.props.contextValue.onSearchParameters(connectorDesc.getSearchParameters.bind(_assertThisInitialized(_this)), {\n            ais: _this.props.contextValue,\n            multiIndexContext: _this.props.indexContextValue\n          }, _this.props, connectorDesc.getMetadata && connectorDesc.getMetadata.bind(_assertThisInitialized(_this)));\n        }\n\n        return _this;\n      }\n\n      _createClass(Connector, [{\n        key: \"componentDidMount\",\n        value: function componentDidMount() {\n          var _this2 = this;\n\n          this.unsubscribe = this.props.contextValue.store.subscribe(function () {\n            if (!_this2.isUnmounting) {\n              _this2.setState({\n                providedProps: _this2.getProvidedProps(_this2.props)\n              });\n            }\n          });\n\n          if (isWidget) {\n            this.unregisterWidget = this.props.contextValue.widgetsManager.registerWidget(this);\n          }\n        }\n      }, {\n        key: \"shouldComponentUpdate\",\n        value: function shouldComponentUpdate(nextProps, nextState) {\n          if (typeof connectorDesc.shouldComponentUpdate === 'function') {\n            return connectorDesc.shouldComponentUpdate.call(this, this.props, nextProps, this.state, nextState);\n          }\n\n          var propsEqual = shallowEqual(this.props, nextProps);\n\n          if (this.state.providedProps === null || nextState.providedProps === null) {\n            if (this.state.providedProps === nextState.providedProps) {\n              return !propsEqual;\n            }\n\n            return true;\n          }\n\n          return !propsEqual || !shallowEqual(this.state.providedProps, nextState.providedProps);\n        }\n      }, {\n        key: \"componentDidUpdate\",\n        value: function componentDidUpdate(prevProps) {\n          if (!isEqual(prevProps, this.props)) {\n            this.setState({\n              providedProps: this.getProvidedProps(this.props)\n            });\n\n            if (isWidget) {\n              this.props.contextValue.widgetsManager.update();\n\n              if (typeof connectorDesc.transitionState === 'function') {\n                this.props.contextValue.onSearchStateChange(connectorDesc.transitionState.call(this, this.props, this.props.contextValue.store.getState().widgets, this.props.contextValue.store.getState().widgets));\n              }\n            }\n          }\n        }\n      }, {\n        key: \"componentWillUnmount\",\n        value: function componentWillUnmount() {\n          this.isUnmounting = true;\n\n          if (this.unsubscribe) {\n            this.unsubscribe();\n          }\n\n          if (this.unregisterWidget) {\n            this.unregisterWidget();\n\n            if (typeof connectorDesc.cleanUp === 'function') {\n              var nextState = connectorDesc.cleanUp.call(this, this.props, this.props.contextValue.store.getState().widgets);\n              this.props.contextValue.store.setState(_objectSpread({}, this.props.contextValue.store.getState(), {\n                widgets: nextState\n              }));\n              this.props.contextValue.onSearchStateChange(removeEmptyKey(nextState));\n            }\n          }\n        }\n      }, {\n        key: \"getProvidedProps\",\n        value: function getProvidedProps(props) {\n          var _this$props$contextVa = this.props.contextValue.store.getState(),\n              widgets = _this$props$contextVa.widgets,\n              results = _this$props$contextVa.results,\n              resultsFacetValues = _this$props$contextVa.resultsFacetValues,\n              searching = _this$props$contextVa.searching,\n              searchingForFacetValues = _this$props$contextVa.searchingForFacetValues,\n              isSearchStalled = _this$props$contextVa.isSearchStalled,\n              metadata = _this$props$contextVa.metadata,\n              error = _this$props$contextVa.error;\n\n          var searchResults = {\n            results: results,\n            searching: searching,\n            searchingForFacetValues: searchingForFacetValues,\n            isSearchStalled: isSearchStalled,\n            error: error\n          };\n          return connectorDesc.getProvidedProps.call(this, props, widgets, searchResults, metadata, // @MAJOR: move this attribute on the `searchResults` it doesn't\n          // makes sense to have it into a separate argument. The search\n          // flags are on the object why not the results?\n          resultsFacetValues);\n        }\n      }, {\n        key: \"getSearchParameters\",\n        value: function getSearchParameters(searchParameters) {\n          if (typeof connectorDesc.getSearchParameters === 'function') {\n            return connectorDesc.getSearchParameters.call(this, searchParameters, this.props, this.props.contextValue.store.getState().widgets);\n          }\n\n          return null;\n        }\n      }, {\n        key: \"getMetadata\",\n        value: function getMetadata(nextWidgetsState) {\n          if (typeof connectorDesc.getMetadata === 'function') {\n            return connectorDesc.getMetadata.call(this, this.props, nextWidgetsState);\n          }\n\n          return {};\n        }\n      }, {\n        key: \"transitionState\",\n        value: function transitionState(prevWidgetsState, nextWidgetsState) {\n          if (typeof connectorDesc.transitionState === 'function') {\n            return connectorDesc.transitionState.call(this, this.props, prevWidgetsState, nextWidgetsState);\n          }\n\n          return nextWidgetsState;\n        }\n      }, {\n        key: \"render\",\n        value: function render() {\n          var _this$props = this.props,\n              contextValue = _this$props.contextValue,\n              props = _objectWithoutProperties(_this$props, [\"contextValue\"]);\n\n          var providedProps = this.state.providedProps;\n\n          if (providedProps === null) {\n            return null;\n          }\n\n          var refineProps = typeof connectorDesc.refine === 'function' ? {\n            refine: this.refine,\n            createURL: this.createURL\n          } : {};\n          var searchForFacetValuesProps = typeof connectorDesc.searchForFacetValues === 'function' ? {\n            searchForItems: this.searchForFacetValues\n          } : {};\n          return React.createElement(Composed, _extends({}, props, providedProps, refineProps, searchForFacetValuesProps));\n        }\n      }]);\n\n      return Connector;\n    }(Component);\n\n    _defineProperty(Connector, \"displayName\", \"\".concat(connectorDesc.displayName, \"(\").concat(getDisplayName(Composed), \")\"));\n\n    _defineProperty(Connector, \"propTypes\", connectorDesc.propTypes);\n\n    _defineProperty(Connector, \"defaultProps\", connectorDesc.defaultProps);\n\n    return Connector;\n  };\n}\n\nvar createConnectorWithContext = function createConnectorWithContext(connectorDesc) {\n  return function (Composed) {\n    var Connector = createConnectorWithoutContext(connectorDesc)(Composed);\n\n    var ConnectorWrapper = function ConnectorWrapper(props) {\n      return React.createElement(InstantSearchConsumer, null, function (contextValue) {\n        return React.createElement(IndexConsumer, null, function (indexContextValue) {\n          return React.createElement(Connector, _extends({\n            contextValue: contextValue,\n            indexContextValue: indexContextValue\n          }, props));\n        });\n      });\n    };\n\n    return ConnectorWrapper;\n  };\n};\n\nexport default createConnectorWithContext;","import \"core-js/modules/es.array.reduce.js\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport { omit } from '../core/utils';\nimport createConnector from '../core/createConnector';\nimport { refineValue, getIndexId, hasMultipleIndices } from '../core/indexUtils';\n\nfunction getId() {\n  return 'configure';\n}\n\nexport default createConnector({\n  displayName: 'AlgoliaConfigure',\n  getProvidedProps: function getProvidedProps() {\n    return {};\n  },\n  getSearchParameters: function getSearchParameters(searchParameters, props) {\n    var children = props.children,\n        contextValue = props.contextValue,\n        indexContextValue = props.indexContextValue,\n        items = _objectWithoutProperties(props, [\"children\", \"contextValue\", \"indexContextValue\"]);\n\n    return searchParameters.setQueryParameters(items);\n  },\n  transitionState: function transitionState(props, prevSearchState, nextSearchState) {\n    var id = getId();\n\n    var children = props.children,\n        contextValue = props.contextValue,\n        indexContextValue = props.indexContextValue,\n        items = _objectWithoutProperties(props, [\"children\", \"contextValue\", \"indexContextValue\"]);\n\n    var propKeys = Object.keys(props);\n    var nonPresentKeys = this._props ? Object.keys(this._props).filter(function (prop) {\n      return propKeys.indexOf(prop) === -1;\n    }) : [];\n    this._props = props;\n\n    var nextValue = _defineProperty({}, id, _objectSpread({}, omit(nextSearchState[id], nonPresentKeys), items));\n\n    return refineValue(nextSearchState, nextValue, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  },\n  cleanUp: function cleanUp(props, searchState) {\n    var id = getId();\n    var indexId = getIndexId({\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n    var subState = hasMultipleIndices({\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    }) && searchState.indices ? searchState.indices[indexId] : searchState;\n    var configureKeys = subState && subState[id] ? Object.keys(subState[id]) : [];\n    var configureState = configureKeys.reduce(function (acc, item) {\n      if (!props[item]) {\n        acc[item] = subState[id][item];\n      }\n\n      return acc;\n    }, {});\n\n    var nextValue = _defineProperty({}, id, configureState);\n\n    return refineValue(searchState, nextValue, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  }\n});","import connectConfigure from '../connectors/connectConfigure';\n/**\n * Configure is a widget that lets you provide raw search parameters\n * to the Algolia API.\n *\n * Any of the props added to this widget will be forwarded to Algolia. For more information\n * on the different parameters that can be set, have a look at the\n * [reference](https://www.algolia.com/doc/api-client/javascript/search#search-parameters).\n *\n * This widget can be used either with react-dom and react-native. It will not render anything\n * on screen, only configure some parameters.\n *\n * Read more in the [Search parameters](guide/Search_parameters.html) guide.\n * @name Configure\n * @kind widget\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, Configure, Hits } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <Configure hitsPerPage={5} />\n *     <Hits />\n *   </InstantSearch>\n * );\n */\n\nexport default connectConfigure(function Configure() {\n  return null;\n});","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport PropTypes from 'prop-types';\nimport createConnector from '../core/createConnector';\nimport { cleanUpValue, refineValue, getCurrentRefinementValue, getIndexId } from '../core/indexUtils';\n\nfunction getId() {\n  return 'query';\n}\n\nfunction getCurrentRefinement(props, searchState, context) {\n  var id = getId(props);\n  var currentRefinement = getCurrentRefinementValue(props, searchState, context, id, '');\n\n  if (currentRefinement) {\n    return currentRefinement;\n  }\n\n  return '';\n}\n\nfunction _refine(props, searchState, nextRefinement, context) {\n  var id = getId();\n\n  var nextValue = _defineProperty({}, id, nextRefinement);\n\n  var resetPage = true;\n  return refineValue(searchState, nextValue, context, resetPage);\n}\n\nfunction _cleanUp(props, searchState, context) {\n  return cleanUpValue(searchState, context, getId());\n}\n/**\n * connectSearchBox connector provides the logic to build a widget that will\n * let the user search for a query\n * @name connectSearchBox\n * @kind connector\n * @propType {string} [defaultRefinement] - Provide a default value for the query\n * @providedPropType {function} refine - a function to change the current query\n * @providedPropType {string} currentRefinement - the current query used\n * @providedPropType {boolean} isSearchStalled - a flag that indicates if InstantSearch has detected that searches are stalled\n */\n\n\nexport default createConnector({\n  displayName: 'AlgoliaSearchBox',\n  propTypes: {\n    defaultRefinement: PropTypes.string\n  },\n  getProvidedProps: function getProvidedProps(props, searchState, searchResults) {\n    return {\n      currentRefinement: getCurrentRefinement(props, searchState, {\n        ais: props.contextValue,\n        multiIndexContext: props.indexContextValue\n      }),\n      isSearchStalled: searchResults.isSearchStalled\n    };\n  },\n  refine: function refine(props, searchState, nextRefinement) {\n    return _refine(props, searchState, nextRefinement, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  },\n  cleanUp: function cleanUp(props, searchState) {\n    return _cleanUp(props, searchState, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n  },\n  getSearchParameters: function getSearchParameters(searchParameters, props, searchState) {\n    return searchParameters.setQuery(getCurrentRefinement(props, searchState, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    }));\n  },\n  getMetadata: function getMetadata(props, searchState) {\n    var id = getId(props);\n    var currentRefinement = getCurrentRefinement(props, searchState, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n    return {\n      id: id,\n      index: getIndexId({\n        ais: props.contextValue,\n        multiIndexContext: props.indexContextValue\n      }),\n      items: currentRefinement === null ? [] : [{\n        label: \"\".concat(id, \": \").concat(currentRefinement),\n        value: function value(nextState) {\n          return _refine(props, nextState, '', {\n            ais: props.contextValue,\n            multiIndexContext: props.indexContextValue\n          });\n        },\n        currentRefinement: currentRefinement\n      }]\n    };\n  }\n});","import React from \"react\";\r\nimport { connectSearchBox } from \"react-instantsearch-dom\";\r\n\r\nexport default connectSearchBox(\r\n  ({ refine, currentRefinement, onFocus, hasFocus }) => (\r\n    <form className=\"flex flex-row-reverse items-center\">\r\n      <input\r\n        className={`py-1 pr-6 pl-2 transition-all ${\r\n          hasFocus ? \"w-64 outline-subtle\" : \"w-32 outline-none cursor-pointer\"\r\n        }`}\r\n        type=\"text\"\r\n        placeholder=\"Search\"\r\n        aria-label=\"Search\"\r\n        onChange={e => refine(e.target.value)}\r\n        value={currentRefinement}\r\n        onFocus={onFocus}\r\n      />\r\n      <svg\r\n        viewBox=\"0 0 24 24\"\r\n        height=\"24\"\r\n        width=\"24\"\r\n        className=\"absolute w-5 m-1 pointer-events-none\"\r\n      >\r\n        <path d=\"M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z\" />\r\n      </svg>\r\n    </form>\r\n  )\r\n);\r\n","import createConnector from '../core/createConnector';\nimport { getResults } from '../core/indexUtils';\n/**\n * The `connectStateResults` connector provides a way to access the `searchState` and the `searchResults`\n * of InstantSearch.\n * For instance this connector allows you to create results/noResults or query/noQuery pages.\n * @name connectStateResults\n * @kind connector\n * @providedPropType {object} searchState - The search state of the instant search component. <br/><br/> See: [Search state structure](https://community.algolia.com/react-instantsearch/guide/Search_state.html)\n * @providedPropType {object} searchResults - The search results. <br/><br/> In case of multiple indices: if used under `<Index>`, results will be those of the corresponding index otherwise it'll be those of the root index  See: [Search results structure](https://community.algolia.com/algoliasearch-helper-js/reference.html#searchresults)\n * @providedPropType {object} allSearchResults - In case of multiple indices you can retrieve all the results\n * @providedPropType {string} error - If the search failed, the error will be logged here.\n * @providedPropType {boolean} searching - If there is a search in progress.\n * @providedPropType {boolean} isSearchStalled - Flag that indicates if React InstantSearch has detected that searches are stalled.\n * @providedPropType {boolean} searchingForFacetValues - If there is a search in a list in progress.\n * @providedPropType {object} props - component props.\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, SearchBox, Hits, connectStateResults } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const Content = connectStateResults(({ searchState, searchResults }) => {\n *   const hasResults = searchResults && searchResults.nbHits !== 0;\n *\n *    return (\n *      <div>\n *        <div hidden={!hasResults}>\n *          <Hits />\n *        </div>\n *        <div hidden={hasResults}>\n *          <div>No results has been found for {searchState.query}</div>\n *        </div>\n *      </div>\n *    );\n * });\n *\n * const App = () => (\n *   <InstantSearch\n *      searchClient={searchClient}\n *      indexName=\"instant_search\"\n *    >\n *      <SearchBox />\n *      <Content />\n *    </InstantSearch>\n * );\n */\n\nexport default createConnector({\n  displayName: 'AlgoliaStateResults',\n  getProvidedProps: function getProvidedProps(props, searchState, searchResults) {\n    var results = getResults(searchResults, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n    return {\n      searchState: searchState,\n      searchResults: results,\n      allSearchResults: searchResults.results,\n      searching: searchResults.searching,\n      isSearchStalled: searchResults.isSearchStalled,\n      error: searchResults.error,\n      searchingForFacetValues: searchResults.searchingForFacetValues,\n      props: props\n    };\n  }\n});","import createConnector from '../core/createConnector';\nimport { HIGHLIGHT_TAGS, parseAlgoliaHit } from '../core/highlight';\n\nvar highlight = function highlight(_ref) {\n  var attribute = _ref.attribute,\n      hit = _ref.hit,\n      highlightProperty = _ref.highlightProperty,\n      _ref$preTag = _ref.preTag,\n      preTag = _ref$preTag === void 0 ? HIGHLIGHT_TAGS.highlightPreTag : _ref$preTag,\n      _ref$postTag = _ref.postTag,\n      postTag = _ref$postTag === void 0 ? HIGHLIGHT_TAGS.highlightPostTag : _ref$postTag;\n  return parseAlgoliaHit({\n    attribute: attribute,\n    highlightProperty: highlightProperty,\n    hit: hit,\n    preTag: preTag,\n    postTag: postTag\n  });\n};\n/**\n * connectHighlight connector provides the logic to create an highlighter\n * component that will retrieve, parse and render an highlighted attribute\n * from an Algolia hit.\n * @name connectHighlight\n * @kind connector\n * @category connector\n * @providedPropType {function} highlight - function to retrieve and parse an attribute from a hit. It takes a configuration object with 3 attributes: `highlightProperty` which is the property that contains the highlight structure from the records, `attribute` which is the name of the attribute (it can be either a string or an array of strings) to look for and `hit` which is the hit from Algolia. It returns an array of objects `{value: string, isHighlighted: boolean}`. If the element that corresponds to the attribute is an array of strings, it will return a nested array of objects.\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, SearchBox, Hits, connectHighlight } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const CustomHighlight = connectHighlight(\n *   ({ highlight, attribute, hit, highlightProperty }) => {\n *     const highlights = highlight({\n *       highlightProperty: '_highlightResult',\n *       attribute,\n *       hit\n *     });\n *\n *     return highlights.map(part => part.isHighlighted ? (\n *       <mark>{part.value}</mark>\n *     ) : (\n *       <span>{part.value}</span>\n *     ));\n *   }\n * );\n *\n * const Hit = ({ hit }) => (\n *   <p>\n *     <CustomHighlight attribute=\"name\" hit={hit} />\n *   </p>\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <SearchBox defaultRefinement=\"pho\" />\n *     <Hits hitComponent={Hit} />\n *   </InstantSearch>\n * );\n */\n\n\nexport default createConnector({\n  displayName: 'AlgoliaHighlighter',\n  propTypes: {},\n  getProvidedProps: function getProvidedProps() {\n    return {\n      highlight: highlight\n    };\n  }\n});","import createConnector from '../core/createConnector';\n/**\n * connectPoweredBy connector provides the logic to build a widget that\n * will display a link to algolia.\n * @name connectPoweredBy\n * @kind connector\n * @providedPropType {string} url - the url to redirect to algolia\n */\n\nexport default createConnector({\n  displayName: 'AlgoliaPoweredBy',\n  getProvidedProps: function getProvidedProps() {\n    var hostname = typeof window === 'undefined' ? '' : window.location.hostname;\n    var url = 'https://www.algolia.com/?' + 'utm_source=react-instantsearch&' + 'utm_medium=website&' + \"utm_content=\".concat(hostname, \"&\") + 'utm_campaign=poweredby';\n    return {\n      url: url\n    };\n  }\n});","import createConnector from '../core/createConnector';\nimport { getResults } from '../core/indexUtils';\nimport { addAbsolutePositions, addQueryID } from '../core/utils';\n/**\n * connectHits connector provides the logic to create connected\n * components that will render the results retrieved from\n * Algolia.\n *\n * To configure the number of hits retrieved, use [HitsPerPage widget](widgets/HitsPerPage.html),\n * [connectHitsPerPage connector](connectors/connectHitsPerPage.html) or pass the hitsPerPage\n * prop to a [Configure](guide/Search_parameters.html) widget.\n *\n * **Warning:** you will need to use the **objectID** property available on every hit as a key\n * when iterating over them. This will ensure you have the best possible UI experience\n * especially on slow networks.\n * @name connectHits\n * @kind connector\n * @providedPropType {array.<object>} hits - the records that matched the search state\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, Highlight, connectHits } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n * const CustomHits = connectHits(({ hits }) => (\n *   <div>\n *     {hits.map(hit =>\n *       <p key={hit.objectID}>\n *         <Highlight attribute=\"name\" hit={hit} />\n *       </p>\n *     )}\n *   </div>\n * ));\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <CustomHits />\n *   </InstantSearch>\n * );\n */\n\nexport default createConnector({\n  displayName: 'AlgoliaHits',\n  getProvidedProps: function getProvidedProps(props, searchState, searchResults) {\n    var results = getResults(searchResults, {\n      ais: props.contextValue,\n      multiIndexContext: props.indexContextValue\n    });\n\n    if (!results) {\n      return {\n        hits: []\n      };\n    }\n\n    var hitsWithPositions = addAbsolutePositions(results.hits, results.hitsPerPage, results.page);\n    var hitsWithPositionsAndQueryID = addQueryID(hitsWithPositions, results.queryID);\n    return {\n      hits: hitsWithPositionsAndQueryID\n    };\n  },\n\n  /**\n   * Hits needs to be considered as a widget to trigger a search,\n   * even if no other widgets are used.\n   *\n   * To be considered as a widget you need either:\n   * - getSearchParameters\n   * - getMetadata\n   * - transitionState\n   *\n   * See: createConnector.tsx\n   */\n  getSearchParameters: function getSearchParameters(searchParameters) {\n    return searchParameters;\n  }\n});","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport React, { Component, Children } from 'react';\nimport PropTypes from 'prop-types';\nimport { InstantSearchConsumer, IndexProvider } from '../core/context';\n\nfunction getIndexContext(props) {\n  return {\n    targetedIndex: props.indexId\n  };\n}\n/**\n * The component that allows you to apply widgets to a dedicated index. It's\n * useful if you want to build an interface that targets multiple indices.\n *\n * @example\n * import React from 'react';\n * import algoliasearch from 'algoliasearch/lite';\n * import { InstantSearch, Index, SearchBox, Hits, Configure } from 'react-instantsearch-dom';\n *\n * const searchClient = algoliasearch(\n *   'latency',\n *   '6be0576ff61c053d5f9a3225e2a90f76'\n * );\n *\n * const App = () => (\n *   <InstantSearch\n *     searchClient={searchClient}\n *     indexName=\"instant_search\"\n *   >\n *     <Configure hitsPerPage={5} />\n *     <SearchBox />\n *     <Index indexName=\"instant_search\">\n *       <Hits />\n *     </Index>\n *     <Index indexName=\"bestbuy\">\n *       <Hits />\n *     </Index>\n *   </InstantSearch>\n * );\n */\n\n\nvar Index = /*#__PURE__*/function (_Component) {\n  _inherits(Index, _Component);\n\n  _createClass(Index, null, [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(props) {\n      return {\n        indexContext: getIndexContext(props)\n      };\n    }\n  }]);\n\n  function Index(props) {\n    var _this;\n\n    _classCallCheck(this, Index);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Index).call(this, props));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      indexContext: getIndexContext(_this.props)\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"unregisterWidget\", void 0);\n\n    _this.props.contextValue.onSearchParameters(_this.getSearchParameters.bind(_assertThisInitialized(_this)), {\n      ais: _this.props.contextValue,\n      multiIndexContext: _this.state.indexContext\n    }, _this.props, undefined);\n\n    return _this;\n  }\n\n  _createClass(Index, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this.unregisterWidget = this.props.contextValue.widgetsManager.registerWidget(this);\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps) {\n      if (this.props.indexName !== prevProps.indexName) {\n        this.props.contextValue.widgetsManager.update();\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (typeof this.unregisterWidget === 'function') {\n        this.unregisterWidget();\n      }\n    }\n  }, {\n    key: \"getSearchParameters\",\n    value: function getSearchParameters(searchParameters, props) {\n      return searchParameters.setIndex(this.props ? this.props.indexName : props.indexName);\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var childrenCount = Children.count(this.props.children);\n\n      if (childrenCount === 0) {\n        return null;\n      }\n\n      return React.createElement(IndexProvider, {\n        value: this.state.indexContext\n      }, this.props.children);\n    }\n  }]);\n\n  return Index;\n}(Component);\n\n_defineProperty(Index, \"propTypes\", {\n  indexName: PropTypes.string.isRequired,\n  indexId: PropTypes.string.isRequired,\n  children: PropTypes.node\n});\n\nvar IndexWrapper = function IndexWrapper(props) {\n  var inferredIndexId = props.indexName;\n  return React.createElement(InstantSearchConsumer, null, function (contextValue) {\n    return React.createElement(Index, _extends({\n      contextValue: contextValue,\n      indexId: inferredIndexId\n    }, props));\n  });\n};\n\nexport var IndexComponentWithoutContext = Index;\nexport default IndexWrapper;","import React from \"react\";\r\n\r\nconst AlgoliaLogo = ({ className }) => (\r\n  <svg\r\n    xmlns=\"http://www.w3.org/2000/svg\"\r\n    baseProfile=\"basic\"\r\n    viewBox=\"0 0 1366 362\"\r\n    width=\"100\"\r\n    height=\"27\"\r\n    className={className}\r\n  >\r\n    <linearGradient\r\n      id=\"g\"\r\n      x1=\"428.258\"\r\n      x2=\"434.145\"\r\n      y1=\"404.15\"\r\n      y2=\"409.85\"\r\n      gradientUnits=\"userSpaceOnUse\"\r\n      gradientTransform=\"matrix(94.045 0 0 -94.072 -40381.527 38479.52)\"\r\n    >\r\n      <stop offset=\"0\" stopColor=\"#00AEFF\"></stop>\r\n      <stop offset=\"1\" stopColor=\"#3369E7\"></stop>\r\n    </linearGradient>\r\n    <path\r\n      d=\"M61.8 15.4h242.8c23.9 0 43.4 19.4 43.4 43.4v242.9c0 23.9-19.4 43.4-43.4 43.4H61.8c-23.9 0-43.4-19.4-43.4-43.4v-243c0-23.9 19.4-43.3 43.4-43.3z\"\r\n      fill=\"url(#g)\"\r\n    ></path>\r\n    <path\r\n      d=\"M187 98.7c-51.4 0-93.1 41.7-93.1 93.2S135.6 285 187 285s93.1-41.7 93.1-93.2-41.6-93.1-93.1-93.1zm0 158.8c-36.2 0-65.6-29.4-65.6-65.6s29.4-65.6 65.6-65.6 65.6 29.4 65.6 65.6-29.3 65.6-65.6 65.6zm0-117.8v48.9c0 1.4 1.5 2.4 2.8 1.7l43.4-22.5c1-.5 1.3-1.7.8-2.7-9-15.8-25.7-26.6-45-27.3-1 0-2 .8-2 1.9zm-60.8-35.9l-5.7-5.7c-5.6-5.6-14.6-5.6-20.2 0l-6.8 6.8c-5.6 5.6-5.6 14.6 0 20.2l5.6 5.6c.9.9 2.2.7 3-.2 3.3-4.5 6.9-8.8 10.9-12.8 4.1-4.1 8.3-7.7 12.9-11 1-.6 1.1-2 .3-2.9zM217.5 89V77.7c0-7.9-6.4-14.3-14.3-14.3h-33.3c-7.9 0-14.3 6.4-14.3 14.3v11.6c0 1.3 1.2 2.2 2.5 1.9 9.3-2.7 19.1-4.1 29-4.1 9.5 0 18.9 1.3 28 3.8 1.2.3 2.4-.6 2.4-1.9z\"\r\n      fill=\"#FFFFFF\"\r\n    ></path>\r\n    <path\r\n      d=\"M842.5 267.6c0 26.7-6.8 46.2-20.5 58.6-13.7 12.4-34.6 18.6-62.8 18.6-10.3 0-31.7-2-48.8-5.8l6.3-31c14.3 3 33.2 3.8 43.1 3.8 15.7 0 26.9-3.2 33.6-9.6s10-15.9 10-28.5v-6.4c-3.9 1.9-9 3.8-15.3 5.8-6.3 1.9-13.6 2.9-21.8 2.9-10.8 0-20.6-1.7-29.5-5.1-8.9-3.4-16.6-8.4-22.9-15-6.3-6.6-11.3-14.9-14.8-24.8s-5.3-27.6-5.3-40.6c0-12.2 1.9-27.5 5.6-37.7 3.8-10.2 9.2-19 16.5-26.3 7.2-7.3 16-12.9 26.3-17s22.4-6.7 35.5-6.7c12.7 0 24.4 1.6 35.8 3.5 11.4 1.9 21.1 3.9 29 6.1v155.2zm-108.7-77.2c0 16.4 3.6 34.6 10.8 42.2 7.2 7.6 16.5 11.4 27.9 11.4 6.2 0 12.1-.9 17.6-2.6 5.5-1.7 9.9-3.7 13.4-6.1v-97.1c-2.8-.6-14.5-3-25.8-3.3-14.2-.4-25 5.4-32.6 14.7-7.5 9.3-11.3 25.6-11.3 40.8zm294.3 0c0 13.2-1.9 23.2-5.8 34.1s-9.4 20.2-16.5 27.9c-7.1 7.7-15.6 13.7-25.6 17.9s-25.4 6.6-33.1 6.6c-7.7-.1-23-2.3-32.9-6.6-9.9-4.3-18.4-10.2-25.5-17.9-7.1-7.7-12.6-17-16.6-27.9s-6-20.9-6-34.1c0-13.2 1.8-25.9 5.8-36.7 4-10.8 9.6-20 16.8-27.7s15.8-13.6 25.6-17.8c9.9-4.2 20.8-6.2 32.6-6.2s22.7 2.1 32.7 6.2c10 4.2 18.6 10.1 25.6 17.8 7.1 7.7 12.6 16.9 16.6 27.7 4.2 10.8 6.3 23.5 6.3 36.7zm-40 .1c0-16.9-3.7-31-10.9-40.8-7.2-9.9-17.3-14.8-30.2-14.8-12.9 0-23 4.9-30.2 14.8-7.2 9.9-10.7 23.9-10.7 40.8 0 17.1 3.6 28.6 10.8 38.5 7.2 10 17.3 14.9 30.2 14.9 12.9 0 23-5 30.2-14.9 7.2-10 10.8-21.4 10.8-38.5zm127.1 86.4c-64.1.3-64.1-51.8-64.1-60.1L1051 32l39.1-6.2v183.6c0 4.7 0 34.5 25.1 34.6v32.9zm68.9 0h-39.3V108.1l39.3-6.2v175zm-19.7-193.5c13.1 0 23.8-10.6 23.8-23.7S1177.6 36 1164.4 36s-23.8 10.6-23.8 23.7 10.7 23.7 23.8 23.7zm117.4 18.6c12.9 0 23.8 1.6 32.6 4.8 8.8 3.2 15.9 7.7 21.1 13.4s8.9 13.5 11.1 21.7c2.3 8.2 3.4 17.2 3.4 27.1v100.6c-6 1.3-15.1 2.8-27.3 4.6s-25.9 2.7-41.1 2.7c-10.1 0-19.4-1-27.7-2.9-8.4-1.9-15.5-5-21.5-9.3-5.9-4.3-10.5-9.8-13.9-16.6-3.3-6.8-5-16.4-5-26.4 0-9.6 1.9-15.7 5.6-22.3 3.8-6.6 8.9-12 15.3-16.2 6.5-4.2 13.9-7.2 22.4-9s17.4-2.7 26.6-2.7c4.3 0 8.8.3 13.6.8s9.8 1.4 15.2 2.7v-6.4c0-4.5-.5-8.8-1.6-12.8-1.1-4.1-3-7.6-5.6-10.7-2.7-3.1-6.2-5.5-10.6-7.2s-10-3-16.7-3c-9 0-17.2 1.1-24.7 2.4-7.5 1.3-13.7 2.8-18.4 4.5l-4.7-32.1c4.9-1.7 12.2-3.4 21.6-5.1s19.5-2.6 30.3-2.6zm3.3 141.9c12 0 20.9-.7 27.1-1.9v-39.8c-2.2-.6-5.3-1.3-9.4-1.9-4.1-.6-8.6-1-13.6-1-4.3 0-8.7.3-13.1 1-4.4.6-8.4 1.8-11.9 3.5s-6.4 4.1-8.5 7.2c-2.2 3.1-3.2 4.9-3.2 9.6 0 9.2 3.2 14.5 9 18 5.9 3.6 13.7 5.3 23.6 5.3zM512.9 103c12.9 0 23.8 1.6 32.6 4.8 8.8 3.2 15.9 7.7 21.1 13.4 5.3 5.8 8.9 13.5 11.1 21.7 2.3 8.2 3.4 17.2 3.4 27.1v100.6c-6 1.3-15.1 2.8-27.3 4.6-12.2 1.8-25.9 2.7-41.1 2.7-10.1 0-19.4-1-27.7-2.9-8.4-1.9-15.5-5-21.5-9.3-5.9-4.3-10.5-9.8-13.9-16.6-3.3-6.8-5-16.4-5-26.4 0-9.6 1.9-15.7 5.6-22.3 3.8-6.6 8.9-12 15.3-16.2 6.5-4.2 13.9-7.2 22.4-9s17.4-2.7 26.6-2.7c4.3 0 8.8.3 13.6.8 4.7.5 9.8 1.4 15.2 2.7v-6.4c0-4.5-.5-8.8-1.6-12.8-1.1-4.1-3-7.6-5.6-10.7-2.7-3.1-6.2-5.5-10.6-7.2-4.4-1.7-10-3-16.7-3-9 0-17.2 1.1-24.7 2.4-7.5 1.3-13.7 2.8-18.4 4.5l-4.7-32.1c4.9-1.7 12.2-3.4 21.6-5.1 9.4-1.8 19.5-2.6 30.3-2.6zm3.4 142c12 0 20.9-.7 27.1-1.9v-39.8c-2.2-.6-5.3-1.3-9.4-1.9-4.1-.6-8.6-1-13.6-1-4.3 0-8.7.3-13.1 1-4.4.6-8.4 1.8-11.9 3.5s-6.4 4.1-8.5 7.2c-2.2 3.1-3.2 4.9-3.2 9.6 0 9.2 3.2 14.5 9 18s13.7 5.3 23.6 5.3zm158.5 31.9c-64.1.3-64.1-51.8-64.1-60.1L610.6 32l39.1-6.2v183.6c0 4.7 0 34.5 25.1 34.6v32.9z\"\r\n      fill=\"#182359\"\r\n    ></path>\r\n  </svg>\r\n);\r\n\r\nexport default AlgoliaLogo;\r\n","import React from \"react\";\r\nimport { Link } from \"gatsby\";\r\nimport {\r\n  connectStateResults,\r\n  connectHighlight,\r\n  connectHits,\r\n  connectPoweredBy,\r\n  Index,\r\n  Snippet,\r\n} from \"react-instantsearch-dom\";\r\n\r\nimport AlgoliaLogo from \"./algolia-logo\";\r\n\r\nimport { useIntl } from \"../../contexts/IntlContext\";\r\n\r\nconst HitCount = connectStateResults(({ searchResults }) => {\r\n  const hitCount = searchResults && searchResults.nbHits;\r\n\r\n  return (\r\n    <div className=\"flex justify-center mb-3.5\">\r\n      {hitCount > 0\r\n        ? `${hitCount} result${hitCount !== 1 ? \"s\" : \"\"}`\r\n        : \"No results\"}\r\n    </div>\r\n  );\r\n});\r\n\r\nconst CustomHighlight = connectHighlight(({ highlight, attribute, hit }) => {\r\n  const parsedHit = highlight({\r\n    highlightProperty: \"_highlightResult\",\r\n    attribute,\r\n    hit,\r\n  });\r\n\r\n  return (\r\n    <span>\r\n      {parsedHit.map((part, index) =>\r\n        part.isHighlighted ? (\r\n          <mark key={index} className=\"bg-green-light\">\r\n            {part.value}\r\n          </mark>\r\n        ) : (\r\n          <span key={index}>{part.value}</span>\r\n        )\r\n      )}\r\n    </span>\r\n  );\r\n});\r\n\r\nconst CustomPoweredBy = connectPoweredBy(({ url }) => (\r\n  <div className=\"flex justify-end items-center mt-3.5 text-xs\">\r\n    <a\r\n      href={url}\r\n      target=\"_blank\"\r\n      aria-label=\"Algolia\"\r\n      rel=\"noopener noreferrer\"\r\n    >\r\n      <span>Search by</span>\r\n      <AlgoliaLogo className=\"w-20 ml-1.5\" />\r\n    </a>\r\n  </div>\r\n));\r\n\r\nconst CustomHits = connectHits(({ hits, lang }) => (\r\n  <ul className=\"max-h-60-screen overflow-y-auto\">\r\n    {hits.map(hit => (\r\n      <li key={hit.objectID}>\r\n        {hit[`paths_${lang}`].map(path => (\r\n          <div key={path} className=\"mb-2 p-1 hover:bg-gray-100\">\r\n            <Link to={path} className=\"block\">\r\n              <CustomHighlight attribute={`title_${lang}`} hit={hit} />\r\n            </Link>\r\n            {/* <Snippet attribute=\"htmlContent\" hit={hit} tagName=\"mark\" /> */}\r\n          </div>\r\n        ))}\r\n      </li>\r\n    ))}\r\n  </ul>\r\n));\r\n\r\nconst SearchResult = ({ indices, show }) => {\r\n  const { lang } = useIntl();\r\n\r\n  return (\r\n    <div\r\n      className={`mt-2 p-4 absolute right-0 top-full z-10 bg-white shadow-lg max-w-lg w-80-screen ${\r\n        show ? \"block\" : \"hidden\"\r\n      }`}\r\n    >\r\n      {indices.map(index => (\r\n        <Index indexName={index.name} key={index.name}>\r\n          <HitCount />\r\n          <CustomHits lang={lang} />\r\n        </Index>\r\n      ))}\r\n      <CustomPoweredBy />\r\n    </div>\r\n  );\r\n};\r\n\r\nexport default SearchResult;\r\n","import { useEffect } from \"react\";\r\n\r\nconst events = [`mousedown`, `touchstart`];\r\n\r\nexport default (ref, onClickOutside) => {\r\n  const isOutside = element => !ref.current || !ref.current.contains(element);\r\n\r\n  const onClick = event => {\r\n    if (isOutside(event.target)) {\r\n      onClickOutside();\r\n    }\r\n  };\r\n\r\n  useEffect(() => {\r\n    for (const event of events) {\r\n      document.addEventListener(event, onClick);\r\n    }\r\n    return () => {\r\n      for (const event of events) document.removeEventListener(event, onClick);\r\n    };\r\n  });\r\n};\r\n","import React, { createRef, useState } from \"react\";\r\nimport algoliasearch from \"algoliasearch/lite\";\r\nimport { Configure, InstantSearch } from \"react-instantsearch-dom\";\r\n\r\nimport { useIntl } from \"../../contexts/IntlContext\";\r\n\r\nimport SearchBox from \"./search-box\";\r\nimport SearchResult from \"./search-result\";\r\nimport useClickOutside from \"./use-click-outside\";\r\n\r\nconst Search = ({ indices }) => {\r\n  const { lang } = useIntl();\r\n  const rootRef = createRef();\r\n  const [query, setQuery] = useState();\r\n  const [hasFocus, setFocus] = useState(false);\r\n  const searchClient = algoliasearch(\r\n    process.env.GATSBY_ALGOLIA_APP_ID,\r\n    process.env.GATSBY_ALGOLIA_SEARCH_KEY\r\n  );\r\n  useClickOutside(rootRef, () => setFocus(false));\r\n\r\n  return (\r\n    <>\r\n      {lang ? (\r\n        <div className=\"relative my-2.5 mr-6 ml-0\" ref={rootRef}>\r\n          <InstantSearch\r\n            searchClient={searchClient}\r\n            indexName={indices[0].name}\r\n            onSearchStateChange={({ query }) => setQuery(query)}\r\n          >\r\n            <Configure restrictSearchableAttributes={[`title_${lang}`]} />\r\n            <SearchBox onFocus={() => setFocus(true)} hasFocus={hasFocus} />\r\n            <SearchResult\r\n              show={query && query.length > 0 && hasFocus}\r\n              indices={indices}\r\n            />\r\n          </InstantSearch>\r\n        </div>\r\n      ) : null}\r\n    </>\r\n  );\r\n};\r\n\r\nexport default Search;\r\n","import React from \"react\";\r\nimport PropTypes from \"prop-types\";\r\nimport { Link, useStaticQuery, graphql } from \"gatsby\";\r\n\r\nimport { useIntl } from \"../contexts/IntlContext\";\r\n\r\nimport LandsLogo from \"./lands-logo\";\r\nimport Language from \"./language\";\r\nimport Search from \"./search\";\r\n\r\nconst searchIndices = [{ name: `Docs`, title: `Docs` }];\r\n\r\nconst Header = ({ siteTitle }) => {\r\n  const { lang } = useIntl();\r\n\r\n  const {\r\n    site: {\r\n      siteMetadata: { defaultLang },\r\n    },\r\n  } = useStaticQuery(graphql`\r\n    query HeaderDefaultLangQuery {\r\n      site {\r\n        siteMetadata {\r\n          defaultLang\r\n        }\r\n      }\r\n    }\r\n  `);\r\n\r\n  return (\r\n    <header className=\"sticky top-0 z-50 bg-gray-100\">\r\n      <div className=\"flex mx-auto h-20 max-w-screen-xl py-3 px-4\">\r\n        <div className=\"flex items-center w-64\">\r\n          <Link\r\n            to={\"/\" + (lang && defaultLang !== lang ? lang : \"\")}\r\n            className=\"overflow-hidden w-9 sm:w-auto\"\r\n            aria-label=\"Link to home page\"\r\n          >\r\n            <span className=\"sr-only\">{siteTitle}</span>\r\n            <LandsLogo rootCssClasses=\"w-auto h-10\" />\r\n          </Link>\r\n        </div>\r\n        <div className=\"flex-auto flex justify-end items-center\">\r\n          <Search indices={searchIndices} />\r\n          <Language />\r\n        </div>\r\n      </div>\r\n    </header>\r\n  );\r\n};\r\n\r\nHeader.propTypes = {\r\n  siteTitle: PropTypes.string,\r\n};\r\n\r\nHeader.defaultProps = {\r\n  siteTitle: ``,\r\n};\r\n\r\nexport default Header;\r\n","import React from \"react\";\r\nimport PropTypes from \"prop-types\";\r\nimport { useStaticQuery, graphql } from \"gatsby\";\r\n\r\nimport \"../styles/content-area.css\";\r\n\r\nimport Header from \"./header\";\r\n\r\nconst Layout = ({ children }) => {\r\n  const data = useStaticQuery(graphql`\r\n    query SiteTitleQuery {\r\n      site {\r\n        siteMetadata {\r\n          title\r\n        }\r\n      }\r\n    }\r\n  `);\r\n\r\n  return (\r\n    <>\r\n      <Header siteTitle={data.site.siteMetadata?.title || `Title`} />\r\n      <main className=\"flex mx-auto max-w-screen-xl px-4\">{children}</main>\r\n    </>\r\n  );\r\n};\r\n\r\nLayout.propTypes = {\r\n  children: PropTypes.node.isRequired,\r\n};\r\n\r\nexport default Layout;\r\n","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar find = require('./find');\n/**\n * Transform sort format from user friendly notation to lodash format\n * @param {string[]} sortBy array of predicate of the form \"attribute:order\"\n * @param {string[]} [defaults] array of predicate of the form \"attribute:order\"\n * @return {array.<string[]>} array containing 2 elements : attributes, orders\n */\n\n\nmodule.exports = function formatSort(sortBy, defaults) {\n  var defaultInstructions = (defaults || []).map(function (sort) {\n    return sort.split(':');\n  });\n  return sortBy.reduce(function preparePredicate(out, sort) {\n    var sortInstruction = sort.split(':');\n    var matchingDefault = find(defaultInstructions, function (defaultInstruction) {\n      return defaultInstruction[0] === sortInstruction[0];\n    });\n\n    if (sortInstruction.length > 1 || !matchingDefault) {\n      out[0].push(sortInstruction[0]);\n      out[1].push(sortInstruction[1]);\n      return out;\n    }\n\n    out[0].push(matchingDefault[0]);\n    out[1].push(matchingDefault[1]);\n    return out;\n  }, [[], []]);\n};","/*! algoliasearch-lite.umd.js | 4.8.4 | © Algolia, inc. | https://github.com/algolia/algoliasearch-client-javascript */\n!function (e, t) {\n  \"object\" == typeof exports && \"undefined\" != typeof module ? module.exports = t() : \"function\" == typeof define && define.amd ? define(t) : (e = e || self).algoliasearch = t();\n}(this, function () {\n  \"use strict\";\n\n  function e(e, t, r) {\n    return t in e ? Object.defineProperty(e, t, {\n      value: r,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }) : e[t] = r, e;\n  }\n\n  function t(e, t) {\n    var r = Object.keys(e);\n\n    if (Object.getOwnPropertySymbols) {\n      var n = Object.getOwnPropertySymbols(e);\n      t && (n = n.filter(function (t) {\n        return Object.getOwnPropertyDescriptor(e, t).enumerable;\n      })), r.push.apply(r, n);\n    }\n\n    return r;\n  }\n\n  function r(r) {\n    for (var n = 1; n < arguments.length; n++) {\n      var o = null != arguments[n] ? arguments[n] : {};\n      n % 2 ? t(Object(o), !0).forEach(function (t) {\n        e(r, t, o[t]);\n      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(o)) : t(Object(o)).forEach(function (e) {\n        Object.defineProperty(r, e, Object.getOwnPropertyDescriptor(o, e));\n      });\n    }\n\n    return r;\n  }\n\n  function n(e, t) {\n    if (null == e) return {};\n\n    var r,\n        n,\n        o = function (e, t) {\n      if (null == e) return {};\n      var r,\n          n,\n          o = {},\n          a = Object.keys(e);\n\n      for (n = 0; n < a.length; n++) {\n        r = a[n], t.indexOf(r) >= 0 || (o[r] = e[r]);\n      }\n\n      return o;\n    }(e, t);\n\n    if (Object.getOwnPropertySymbols) {\n      var a = Object.getOwnPropertySymbols(e);\n\n      for (n = 0; n < a.length; n++) {\n        r = a[n], t.indexOf(r) >= 0 || Object.prototype.propertyIsEnumerable.call(e, r) && (o[r] = e[r]);\n      }\n    }\n\n    return o;\n  }\n\n  function o(e, t) {\n    return function (e) {\n      if (Array.isArray(e)) return e;\n    }(e) || function (e, t) {\n      if (!(Symbol.iterator in Object(e) || \"[object Arguments]\" === Object.prototype.toString.call(e))) return;\n      var r = [],\n          n = !0,\n          o = !1,\n          a = void 0;\n\n      try {\n        for (var u, i = e[Symbol.iterator](); !(n = (u = i.next()).done) && (r.push(u.value), !t || r.length !== t); n = !0) {\n          ;\n        }\n      } catch (e) {\n        o = !0, a = e;\n      } finally {\n        try {\n          n || null == i.return || i.return();\n        } finally {\n          if (o) throw a;\n        }\n      }\n\n      return r;\n    }(e, t) || function () {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }();\n  }\n\n  function a(e) {\n    return function (e) {\n      if (Array.isArray(e)) {\n        for (var t = 0, r = new Array(e.length); t < e.length; t++) {\n          r[t] = e[t];\n        }\n\n        return r;\n      }\n    }(e) || function (e) {\n      if (Symbol.iterator in Object(e) || \"[object Arguments]\" === Object.prototype.toString.call(e)) return Array.from(e);\n    }(e) || function () {\n      throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n    }();\n  }\n\n  function u(e) {\n    var t,\n        r = \"algoliasearch-client-js-\".concat(e.key),\n        n = function n() {\n      return void 0 === t && (t = e.localStorage || window.localStorage), t;\n    },\n        a = function a() {\n      return JSON.parse(n().getItem(r) || \"{}\");\n    };\n\n    return {\n      get: function get(e, t) {\n        var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {\n          miss: function miss() {\n            return Promise.resolve();\n          }\n        };\n        return Promise.resolve().then(function () {\n          var r = JSON.stringify(e),\n              n = a()[r];\n          return Promise.all([n || t(), void 0 !== n]);\n        }).then(function (e) {\n          var t = o(e, 2),\n              n = t[0],\n              a = t[1];\n          return Promise.all([n, a || r.miss(n)]);\n        }).then(function (e) {\n          return o(e, 1)[0];\n        });\n      },\n      set: function set(e, t) {\n        return Promise.resolve().then(function () {\n          var o = a();\n          return o[JSON.stringify(e)] = t, n().setItem(r, JSON.stringify(o)), t;\n        });\n      },\n      delete: function _delete(e) {\n        return Promise.resolve().then(function () {\n          var t = a();\n          delete t[JSON.stringify(e)], n().setItem(r, JSON.stringify(t));\n        });\n      },\n      clear: function clear() {\n        return Promise.resolve().then(function () {\n          n().removeItem(r);\n        });\n      }\n    };\n  }\n\n  function i(e) {\n    var t = a(e.caches),\n        r = t.shift();\n    return void 0 === r ? {\n      get: function get(e, t) {\n        var r = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {\n          miss: function miss() {\n            return Promise.resolve();\n          }\n        },\n            n = t();\n        return n.then(function (e) {\n          return Promise.all([e, r.miss(e)]);\n        }).then(function (e) {\n          return o(e, 1)[0];\n        });\n      },\n      set: function set(e, t) {\n        return Promise.resolve(t);\n      },\n      delete: function _delete(e) {\n        return Promise.resolve();\n      },\n      clear: function clear() {\n        return Promise.resolve();\n      }\n    } : {\n      get: function get(e, n) {\n        var o = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {\n          miss: function miss() {\n            return Promise.resolve();\n          }\n        };\n        return r.get(e, n, o).catch(function () {\n          return i({\n            caches: t\n          }).get(e, n, o);\n        });\n      },\n      set: function set(e, n) {\n        return r.set(e, n).catch(function () {\n          return i({\n            caches: t\n          }).set(e, n);\n        });\n      },\n      delete: function _delete(e) {\n        return r.delete(e).catch(function () {\n          return i({\n            caches: t\n          }).delete(e);\n        });\n      },\n      clear: function clear() {\n        return r.clear().catch(function () {\n          return i({\n            caches: t\n          }).clear();\n        });\n      }\n    };\n  }\n\n  function s() {\n    var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {\n      serializable: !0\n    },\n        t = {};\n    return {\n      get: function get(r, n) {\n        var o = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {\n          miss: function miss() {\n            return Promise.resolve();\n          }\n        },\n            a = JSON.stringify(r);\n        if (a in t) return Promise.resolve(e.serializable ? JSON.parse(t[a]) : t[a]);\n\n        var u = n(),\n            i = o && o.miss || function () {\n          return Promise.resolve();\n        };\n\n        return u.then(function (e) {\n          return i(e);\n        }).then(function () {\n          return u;\n        });\n      },\n      set: function set(r, n) {\n        return t[JSON.stringify(r)] = e.serializable ? JSON.stringify(n) : n, Promise.resolve(n);\n      },\n      delete: function _delete(e) {\n        return delete t[JSON.stringify(e)], Promise.resolve();\n      },\n      clear: function clear() {\n        return t = {}, Promise.resolve();\n      }\n    };\n  }\n\n  function c(e) {\n    for (var t = e.length - 1; t > 0; t--) {\n      var r = Math.floor(Math.random() * (t + 1)),\n          n = e[t];\n      e[t] = e[r], e[r] = n;\n    }\n\n    return e;\n  }\n\n  function l(e, t) {\n    return t ? (Object.keys(t).forEach(function (r) {\n      e[r] = t[r](e);\n    }), e) : e;\n  }\n\n  function f(e) {\n    for (var t = arguments.length, r = new Array(t > 1 ? t - 1 : 0), n = 1; n < t; n++) {\n      r[n - 1] = arguments[n];\n    }\n\n    var o = 0;\n    return e.replace(/%s/g, function () {\n      return encodeURIComponent(r[o++]);\n    });\n  }\n\n  var h = {\n    WithinQueryParameters: 0,\n    WithinHeaders: 1\n  };\n\n  function d(e, t) {\n    var r = e || {},\n        n = r.data || {};\n    return Object.keys(r).forEach(function (e) {\n      -1 === [\"timeout\", \"headers\", \"queryParameters\", \"data\", \"cacheable\"].indexOf(e) && (n[e] = r[e]);\n    }), {\n      data: Object.entries(n).length > 0 ? n : void 0,\n      timeout: r.timeout || t,\n      headers: r.headers || {},\n      queryParameters: r.queryParameters || {},\n      cacheable: r.cacheable\n    };\n  }\n\n  var m = {\n    Read: 1,\n    Write: 2,\n    Any: 3\n  },\n      p = 1,\n      v = 2,\n      y = 3;\n\n  function g(e) {\n    var t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : p;\n    return r(r({}, e), {}, {\n      status: t,\n      lastUpdate: Date.now()\n    });\n  }\n\n  function b(e) {\n    return \"string\" == typeof e ? {\n      protocol: \"https\",\n      url: e,\n      accept: m.Any\n    } : {\n      protocol: e.protocol || \"https\",\n      url: e.url,\n      accept: e.accept || m.Any\n    };\n  }\n\n  var O = \"GET\",\n      P = \"POST\";\n\n  function q(e, t) {\n    return Promise.all(t.map(function (t) {\n      return e.get(t, function () {\n        return Promise.resolve(g(t));\n      });\n    })).then(function (e) {\n      var r = e.filter(function (e) {\n        return function (e) {\n          return e.status === p || Date.now() - e.lastUpdate > 12e4;\n        }(e);\n      }),\n          n = e.filter(function (e) {\n        return function (e) {\n          return e.status === y && Date.now() - e.lastUpdate <= 12e4;\n        }(e);\n      }),\n          o = [].concat(a(r), a(n));\n      return {\n        getTimeout: function getTimeout(e, t) {\n          return (0 === n.length && 0 === e ? 1 : n.length + 3 + e) * t;\n        },\n        statelessHosts: o.length > 0 ? o.map(function (e) {\n          return b(e);\n        }) : t\n      };\n    });\n  }\n\n  function j(e, t, n, o) {\n    var u = [],\n        i = function (e, t) {\n      if (e.method === O || void 0 === e.data && void 0 === t.data) return;\n      var n = Array.isArray(e.data) ? e.data : r(r({}, e.data), t.data);\n      return JSON.stringify(n);\n    }(n, o),\n        s = function (e, t) {\n      var n = r(r({}, e.headers), t.headers),\n          o = {};\n      return Object.keys(n).forEach(function (e) {\n        var t = n[e];\n        o[e.toLowerCase()] = t;\n      }), o;\n    }(e, o),\n        c = n.method,\n        l = n.method !== O ? {} : r(r({}, n.data), o.data),\n        f = r(r(r({\n      \"x-algolia-agent\": e.userAgent.value\n    }, e.queryParameters), l), o.queryParameters),\n        h = 0,\n        d = function t(r, a) {\n      var l = r.pop();\n      if (void 0 === l) throw {\n        name: \"RetryError\",\n        message: \"Unreachable hosts - your application id may be incorrect. If the error persists, contact support@algolia.com.\",\n        transporterStackTrace: A(u)\n      };\n\n      var d = {\n        data: i,\n        headers: s,\n        method: c,\n        url: S(l, n.path, f),\n        connectTimeout: a(h, e.timeouts.connect),\n        responseTimeout: a(h, o.timeout)\n      },\n          m = function m(e) {\n        var t = {\n          request: d,\n          response: e,\n          host: l,\n          triesLeft: r.length\n        };\n        return u.push(t), t;\n      },\n          p = {\n        onSucess: function onSucess(e) {\n          return function (e) {\n            try {\n              return JSON.parse(e.content);\n            } catch (t) {\n              throw function (e, t) {\n                return {\n                  name: \"DeserializationError\",\n                  message: e,\n                  response: t\n                };\n              }(t.message, e);\n            }\n          }(e);\n        },\n        onRetry: function onRetry(n) {\n          var o = m(n);\n          return n.isTimedOut && h++, Promise.all([e.logger.info(\"Retryable failure\", x(o)), e.hostsCache.set(l, g(l, n.isTimedOut ? y : v))]).then(function () {\n            return t(r, a);\n          });\n        },\n        onFail: function onFail(e) {\n          throw m(e), function (e, t) {\n            var r = e.content,\n                n = e.status,\n                o = r;\n\n            try {\n              o = JSON.parse(r).message;\n            } catch (e) {}\n\n            return function (e, t, r) {\n              return {\n                name: \"ApiError\",\n                message: e,\n                status: t,\n                transporterStackTrace: r\n              };\n            }(o, n, t);\n          }(e, A(u));\n        }\n      };\n\n      return e.requester.send(d).then(function (e) {\n        return function (e, t) {\n          return function (e) {\n            var t = e.status;\n            return e.isTimedOut || function (e) {\n              var t = e.isTimedOut,\n                  r = e.status;\n              return !t && 0 == ~~r;\n            }(e) || 2 != ~~(t / 100) && 4 != ~~(t / 100);\n          }(e) ? t.onRetry(e) : 2 == ~~(e.status / 100) ? t.onSucess(e) : t.onFail(e);\n        }(e, p);\n      });\n    };\n\n    return q(e.hostsCache, t).then(function (e) {\n      return d(a(e.statelessHosts).reverse(), e.getTimeout);\n    });\n  }\n\n  function w(e) {\n    var t = {\n      value: \"Algolia for JavaScript (\".concat(e, \")\"),\n      add: function add(e) {\n        var r = \"; \".concat(e.segment).concat(void 0 !== e.version ? \" (\".concat(e.version, \")\") : \"\");\n        return -1 === t.value.indexOf(r) && (t.value = \"\".concat(t.value).concat(r)), t;\n      }\n    };\n    return t;\n  }\n\n  function S(e, t, r) {\n    var n = T(r),\n        o = \"\".concat(e.protocol, \"://\").concat(e.url, \"/\").concat(\"/\" === t.charAt(0) ? t.substr(1) : t);\n    return n.length && (o += \"?\".concat(n)), o;\n  }\n\n  function T(e) {\n    return Object.keys(e).map(function (t) {\n      return f(\"%s=%s\", t, (r = e[t], \"[object Object]\" === Object.prototype.toString.call(r) || \"[object Array]\" === Object.prototype.toString.call(r) ? JSON.stringify(e[t]) : e[t]));\n      var r;\n    }).join(\"&\");\n  }\n\n  function A(e) {\n    return e.map(function (e) {\n      return x(e);\n    });\n  }\n\n  function x(e) {\n    var t = e.request.headers[\"x-algolia-api-key\"] ? {\n      \"x-algolia-api-key\": \"*****\"\n    } : {};\n    return r(r({}, e), {}, {\n      request: r(r({}, e.request), {}, {\n        headers: r(r({}, e.request.headers), t)\n      })\n    });\n  }\n\n  var N = function N(e) {\n    var t = e.appId,\n        n = function (e, t, r) {\n      var n = {\n        \"x-algolia-api-key\": r,\n        \"x-algolia-application-id\": t\n      };\n      return {\n        headers: function headers() {\n          return e === h.WithinHeaders ? n : {};\n        },\n        queryParameters: function queryParameters() {\n          return e === h.WithinQueryParameters ? n : {};\n        }\n      };\n    }(void 0 !== e.authMode ? e.authMode : h.WithinHeaders, t, e.apiKey),\n        a = function (e) {\n      var t = e.hostsCache,\n          r = e.logger,\n          n = e.requester,\n          a = e.requestsCache,\n          u = e.responsesCache,\n          i = e.timeouts,\n          s = e.userAgent,\n          c = e.hosts,\n          l = e.queryParameters,\n          f = {\n        hostsCache: t,\n        logger: r,\n        requester: n,\n        requestsCache: a,\n        responsesCache: u,\n        timeouts: i,\n        userAgent: s,\n        headers: e.headers,\n        queryParameters: l,\n        hosts: c.map(function (e) {\n          return b(e);\n        }),\n        read: function read(e, t) {\n          var r = d(t, f.timeouts.read),\n              n = function n() {\n            return j(f, f.hosts.filter(function (e) {\n              return 0 != (e.accept & m.Read);\n            }), e, r);\n          };\n\n          if (!0 !== (void 0 !== r.cacheable ? r.cacheable : e.cacheable)) return n();\n          var a = {\n            request: e,\n            mappedRequestOptions: r,\n            transporter: {\n              queryParameters: f.queryParameters,\n              headers: f.headers\n            }\n          };\n          return f.responsesCache.get(a, function () {\n            return f.requestsCache.get(a, function () {\n              return f.requestsCache.set(a, n()).then(function (e) {\n                return Promise.all([f.requestsCache.delete(a), e]);\n              }, function (e) {\n                return Promise.all([f.requestsCache.delete(a), Promise.reject(e)]);\n              }).then(function (e) {\n                var t = o(e, 2);\n                t[0];\n                return t[1];\n              });\n            });\n          }, {\n            miss: function miss(e) {\n              return f.responsesCache.set(a, e);\n            }\n          });\n        },\n        write: function write(e, t) {\n          return j(f, f.hosts.filter(function (e) {\n            return 0 != (e.accept & m.Write);\n          }), e, d(t, f.timeouts.write));\n        }\n      };\n      return f;\n    }(r(r({\n      hosts: [{\n        url: \"\".concat(t, \"-dsn.algolia.net\"),\n        accept: m.Read\n      }, {\n        url: \"\".concat(t, \".algolia.net\"),\n        accept: m.Write\n      }].concat(c([{\n        url: \"\".concat(t, \"-1.algolianet.com\")\n      }, {\n        url: \"\".concat(t, \"-2.algolianet.com\")\n      }, {\n        url: \"\".concat(t, \"-3.algolianet.com\")\n      }]))\n    }, e), {}, {\n      headers: r(r(r({}, n.headers()), {\n        \"content-type\": \"application/x-www-form-urlencoded\"\n      }), e.headers),\n      queryParameters: r(r({}, n.queryParameters()), e.queryParameters)\n    }));\n\n    return l({\n      transporter: a,\n      appId: t,\n      addAlgoliaAgent: function addAlgoliaAgent(e, t) {\n        a.userAgent.add({\n          segment: e,\n          version: t\n        });\n      },\n      clearCache: function clearCache() {\n        return Promise.all([a.requestsCache.clear(), a.responsesCache.clear()]).then(function () {});\n      }\n    }, e.methods);\n  },\n      C = function C(e) {\n    return function (t) {\n      var r = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {},\n          n = {\n        transporter: e.transporter,\n        appId: e.appId,\n        indexName: t\n      };\n      return l(n, r.methods);\n    };\n  },\n      k = function k(e) {\n    return function (t, n) {\n      var o = t.map(function (e) {\n        return r(r({}, e), {}, {\n          params: T(e.params || {})\n        });\n      });\n      return e.transporter.read({\n        method: P,\n        path: \"1/indexes/*/queries\",\n        data: {\n          requests: o\n        },\n        cacheable: !0\n      }, n);\n    };\n  },\n      J = function J(e) {\n    return function (t, o) {\n      return Promise.all(t.map(function (t) {\n        var a = t.params,\n            u = a.facetName,\n            i = a.facetQuery,\n            s = n(a, [\"facetName\", \"facetQuery\"]);\n        return C(e)(t.indexName, {\n          methods: {\n            searchForFacetValues: F\n          }\n        }).searchForFacetValues(u, i, r(r({}, o), s));\n      }));\n    };\n  },\n      E = function E(e) {\n    return function (t, r, n) {\n      return e.transporter.read({\n        method: P,\n        path: f(\"1/answers/%s/prediction\", e.indexName),\n        data: {\n          query: t,\n          queryLanguages: r\n        },\n        cacheable: !0\n      }, n);\n    };\n  },\n      I = function I(e) {\n    return function (t, r) {\n      return e.transporter.read({\n        method: P,\n        path: f(\"1/indexes/%s/query\", e.indexName),\n        data: {\n          query: t\n        },\n        cacheable: !0\n      }, r);\n    };\n  },\n      F = function F(e) {\n    return function (t, r, n) {\n      return e.transporter.read({\n        method: P,\n        path: f(\"1/indexes/%s/facets/%s/query\", e.indexName, t),\n        data: {\n          facetQuery: r\n        },\n        cacheable: !0\n      }, n);\n    };\n  },\n      R = 1,\n      D = 2,\n      W = 3;\n\n  function H(e, t, n) {\n    var o,\n        a = {\n      appId: e,\n      apiKey: t,\n      timeouts: {\n        connect: 1,\n        read: 2,\n        write: 30\n      },\n      requester: {\n        send: function send(e) {\n          return new Promise(function (t) {\n            var r = new XMLHttpRequest();\n            r.open(e.method, e.url, !0), Object.keys(e.headers).forEach(function (t) {\n              return r.setRequestHeader(t, e.headers[t]);\n            });\n\n            var n,\n                o = function o(e, n) {\n              return setTimeout(function () {\n                r.abort(), t({\n                  status: 0,\n                  content: n,\n                  isTimedOut: !0\n                });\n              }, 1e3 * e);\n            },\n                a = o(e.connectTimeout, \"Connection timeout\");\n\n            r.onreadystatechange = function () {\n              r.readyState > r.OPENED && void 0 === n && (clearTimeout(a), n = o(e.responseTimeout, \"Socket timeout\"));\n            }, r.onerror = function () {\n              0 === r.status && (clearTimeout(a), clearTimeout(n), t({\n                content: r.responseText || \"Network request failed\",\n                status: r.status,\n                isTimedOut: !1\n              }));\n            }, r.onload = function () {\n              clearTimeout(a), clearTimeout(n), t({\n                content: r.responseText,\n                status: r.status,\n                isTimedOut: !1\n              });\n            }, r.send(e.data);\n          });\n        }\n      },\n      logger: (o = W, {\n        debug: function debug(e, t) {\n          return R >= o && console.debug(e, t), Promise.resolve();\n        },\n        info: function info(e, t) {\n          return D >= o && console.info(e, t), Promise.resolve();\n        },\n        error: function error(e, t) {\n          return console.error(e, t), Promise.resolve();\n        }\n      }),\n      responsesCache: s(),\n      requestsCache: s({\n        serializable: !1\n      }),\n      hostsCache: i({\n        caches: [u({\n          key: \"\".concat(\"4.8.4\", \"-\").concat(e)\n        }), s()]\n      }),\n      userAgent: w(\"4.8.4\").add({\n        segment: \"Browser\",\n        version: \"lite\"\n      }),\n      authMode: h.WithinQueryParameters\n    };\n    return N(r(r(r({}, a), n), {}, {\n      methods: {\n        search: k,\n        searchForFacetValues: J,\n        multipleQueries: k,\n        multipleSearchForFacetValues: J,\n        initIndex: function initIndex(e) {\n          return function (t) {\n            return C(e)(t, {\n              methods: {\n                search: I,\n                searchForFacetValues: F,\n                findAnswers: E\n              }\n            });\n          };\n        }\n      }\n    }));\n  }\n\n  return H.version = \"4.8.4\", H;\n});","'use strict';\n\nfunction clone(value) {\n  if (typeof value === 'object' && value !== null) {\n    return _merge(Array.isArray(value) ? [] : {}, value);\n  }\n\n  return value;\n}\n\nfunction isObjectOrArrayOrFunction(value) {\n  return typeof value === 'function' || Array.isArray(value) || Object.prototype.toString.call(value) === '[object Object]';\n}\n\nfunction _merge(target, source) {\n  if (target === source) {\n    return target;\n  }\n\n  for (var key in source) {\n    if (!Object.prototype.hasOwnProperty.call(source, key)) {\n      continue;\n    }\n\n    var sourceVal = source[key];\n    var targetVal = target[key];\n\n    if (typeof targetVal !== 'undefined' && typeof sourceVal === 'undefined') {\n      continue;\n    }\n\n    if (isObjectOrArrayOrFunction(targetVal) && isObjectOrArrayOrFunction(sourceVal)) {\n      target[key] = _merge(targetVal, sourceVal);\n    } else {\n      target[key] = clone(sourceVal);\n    }\n  }\n\n  return target;\n}\n/**\n * This method is like Object.assign, but recursively merges own and inherited\n * enumerable keyed properties of source objects into the destination object.\n *\n * NOTE: this behaves like lodash/merge, but:\n * - does mutate functions if they are a source\n * - treats non-plain objects as plain\n * - does not work for circular objects\n * - treats sparse arrays as sparse\n * - does not convert Array-like objects (Arguments, NodeLists, etc.) to arrays\n *\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n */\n\n\nfunction merge(target) {\n  if (!isObjectOrArrayOrFunction(target)) {\n    target = {};\n  }\n\n  for (var i = 1, l = arguments.length; i < l; i++) {\n    var source = arguments[i];\n\n    if (isObjectOrArrayOrFunction(source)) {\n      _merge(target, source);\n    }\n  }\n\n  return target;\n}\n\nmodule.exports = merge;","'use strict'; // @MAJOR can be replaced by native Array#find when we change support\n\nmodule.exports = function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return undefined;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return array[i];\n    }\n  }\n};","'use strict';\n/**\n * Functions to manipulate refinement lists\n *\n * The RefinementList is not formally defined through a prototype but is based\n * on a specific structure.\n *\n * @module SearchParameters.refinementList\n *\n * @typedef {string[]} SearchParameters.refinementList.Refinements\n * @typedef {Object.<string, SearchParameters.refinementList.Refinements>} SearchParameters.refinementList.RefinementList\n */\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar defaultsPure = require('../functions/defaultsPure');\n\nvar omit = require('../functions/omit');\n\nvar objectHasKeys = require('../functions/objectHasKeys');\n\nvar lib = {\n  /**\n   * Adds a refinement to a RefinementList\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} value the value of the refinement, if the value is not a string it will be converted\n   * @return {RefinementList} a new and updated refinement list\n   */\n  addRefinement: function addRefinement(refinementList, attribute, value) {\n    if (lib.isRefined(refinementList, attribute, value)) {\n      return refinementList;\n    }\n\n    var valueAsString = '' + value;\n    var facetRefinement = !refinementList[attribute] ? [valueAsString] : refinementList[attribute].concat(valueAsString);\n    var mod = {};\n    mod[attribute] = facetRefinement;\n    return defaultsPure({}, mod, refinementList);\n  },\n\n  /**\n   * Removes refinement(s) for an attribute:\n   *  - if the value is specified removes the refinement for the value on the attribute\n   *  - if no value is specified removes all the refinements for this attribute\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} [value] the value of the refinement\n   * @return {RefinementList} a new and updated refinement lst\n   */\n  removeRefinement: function removeRefinement(refinementList, attribute, value) {\n    if (value === undefined) {\n      // we use the \"filter\" form of clearRefinement, since it leaves empty values as-is\n      // the form with a string will remove the attribute completely\n      return lib.clearRefinement(refinementList, function (v, f) {\n        return attribute === f;\n      });\n    }\n\n    var valueAsString = '' + value;\n    return lib.clearRefinement(refinementList, function (v, f) {\n      return attribute === f && valueAsString === v;\n    });\n  },\n\n  /**\n   * Toggles the refinement value for an attribute.\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} attribute the attribute to refine\n   * @param {string} value the value of the refinement\n   * @return {RefinementList} a new and updated list\n   */\n  toggleRefinement: function toggleRefinement(refinementList, attribute, value) {\n    if (value === undefined) throw new Error('toggleRefinement should be used with a value');\n\n    if (lib.isRefined(refinementList, attribute, value)) {\n      return lib.removeRefinement(refinementList, attribute, value);\n    }\n\n    return lib.addRefinement(refinementList, attribute, value);\n  },\n\n  /**\n   * Clear all or parts of a RefinementList. Depending on the arguments, three\n   * kinds of behavior can happen:\n   *  - if no attribute is provided: clears the whole list\n   *  - if an attribute is provided as a string: clears the list for the specific attribute\n   *  - if an attribute is provided as a function: discards the elements for which the function returns true\n   * @param {RefinementList} refinementList the initial list\n   * @param {string} [attribute] the attribute or function to discard\n   * @param {string} [refinementType] optional parameter to give more context to the attribute function\n   * @return {RefinementList} a new and updated refinement list\n   */\n  clearRefinement: function clearRefinement(refinementList, attribute, refinementType) {\n    if (attribute === undefined) {\n      if (!objectHasKeys(refinementList)) {\n        return refinementList;\n      }\n\n      return {};\n    } else if (typeof attribute === 'string') {\n      return omit(refinementList, [attribute]);\n    } else if (typeof attribute === 'function') {\n      var hasChanged = false;\n      var newRefinementList = Object.keys(refinementList).reduce(function (memo, key) {\n        var values = refinementList[key] || [];\n        var facetList = values.filter(function (value) {\n          return !attribute(value, key, refinementType);\n        });\n\n        if (facetList.length !== values.length) {\n          hasChanged = true;\n        }\n\n        memo[key] = facetList;\n        return memo;\n      }, {});\n      if (hasChanged) return newRefinementList;\n      return refinementList;\n    }\n  },\n\n  /**\n   * Test if the refinement value is used for the attribute. If no refinement value\n   * is provided, test if the refinementList contains any refinement for the\n   * given attribute.\n   * @param {RefinementList} refinementList the list of refinement\n   * @param {string} attribute name of the attribute\n   * @param {string} [refinementValue] value of the filter/refinement\n   * @return {boolean}\n   */\n  isRefined: function isRefined(refinementList, attribute, refinementValue) {\n    var containsRefinements = !!refinementList[attribute] && refinementList[attribute].length > 0;\n\n    if (refinementValue === undefined || !containsRefinements) {\n      return containsRefinements;\n    }\n\n    var refinementValueAsString = '' + refinementValue;\n    return refinementList[attribute].indexOf(refinementValueAsString) !== -1;\n  }\n};\nmodule.exports = lib;","'use strict';\n\nvar events = require('events');\n\nvar inherits = require('../functions/inherits');\n/**\n * A DerivedHelper is a way to create sub requests to\n * Algolia from a main helper.\n * @class\n * @classdesc The DerivedHelper provides an event based interface for search callbacks:\n *  - search: when a search is triggered using the `search()` method.\n *  - result: when the response is retrieved from Algolia and is processed.\n *    This event contains a {@link SearchResults} object and the\n *    {@link SearchParameters} corresponding to this answer.\n */\n\n\nfunction DerivedHelper(mainHelper, fn) {\n  this.main = mainHelper;\n  this.fn = fn;\n  this.lastResults = null;\n}\n\ninherits(DerivedHelper, events.EventEmitter);\n/**\n * Detach this helper from the main helper\n * @return {undefined}\n * @throws Error if the derived helper is already detached\n */\n\nDerivedHelper.prototype.detach = function () {\n  this.removeAllListeners();\n  this.main.detachDerivedHelper(this);\n};\n\nDerivedHelper.prototype.getModifiedState = function (parameters) {\n  return this.fn(parameters);\n};\n\nmodule.exports = DerivedHelper;","'use strict';\n\nvar AlgoliaSearchHelper = require('./src/algoliasearch.helper');\n\nvar SearchParameters = require('./src/SearchParameters');\n\nvar SearchResults = require('./src/SearchResults');\n/**\n * The algoliasearchHelper module is the function that will let its\n * contains everything needed to use the Algoliasearch\n * Helper. It is a also a function that instanciate the helper.\n * To use the helper, you also need the Algolia JS client v3.\n * @example\n * //using the UMD build\n * var client = algoliasearch('latency', '6be0576ff61c053d5f9a3225e2a90f76');\n * var helper = algoliasearchHelper(client, 'bestbuy', {\n *   facets: ['shipping'],\n *   disjunctiveFacets: ['category']\n * });\n * helper.on('result', function(event) {\n *   console.log(event.results);\n * });\n * helper\n *   .toggleFacetRefinement('category', 'Movies & TV Shows')\n *   .toggleFacetRefinement('shipping', 'Free shipping')\n *   .search();\n * @example\n * // The helper is an event emitter using the node API\n * helper.on('result', updateTheResults);\n * helper.once('result', updateTheResults);\n * helper.removeListener('result', updateTheResults);\n * helper.removeAllListeners('result');\n * @module algoliasearchHelper\n * @param  {AlgoliaSearch} client an AlgoliaSearch client\n * @param  {string} index the name of the index to query\n * @param  {SearchParameters|object} opts an object defining the initial config of the search. It doesn't have to be a {SearchParameters}, just an object containing the properties you need from it.\n * @return {AlgoliaSearchHelper}\n */\n\n\nfunction algoliasearchHelper(client, index, opts) {\n  return new AlgoliaSearchHelper(client, index, opts);\n}\n/**\n * The version currently used\n * @member module:algoliasearchHelper.version\n * @type {number}\n */\n\n\nalgoliasearchHelper.version = require('./src/version.js');\n/**\n * Constructor for the Helper.\n * @member module:algoliasearchHelper.AlgoliaSearchHelper\n * @type {AlgoliaSearchHelper}\n */\n\nalgoliasearchHelper.AlgoliaSearchHelper = AlgoliaSearchHelper;\n/**\n * Constructor for the object containing all the parameters of the search.\n * @member module:algoliasearchHelper.SearchParameters\n * @type {SearchParameters}\n */\n\nalgoliasearchHelper.SearchParameters = SearchParameters;\n/**\n * Constructor for the object containing the results of the search.\n * @member module:algoliasearchHelper.SearchResults\n * @type {SearchResults}\n */\n\nalgoliasearchHelper.SearchResults = SearchResults;\nmodule.exports = algoliasearchHelper;","'use strict';\n\nfunction inherits(ctor, superCtor) {\n  ctor.prototype = Object.create(superCtor.prototype, {\n    constructor: {\n      value: ctor,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n}\n\nmodule.exports = inherits;","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar merge = require('../functions/merge');\n\nvar defaultsPure = require('../functions/defaultsPure');\n\nvar intersection = require('../functions/intersection');\n\nvar find = require('../functions/find');\n\nvar valToNumber = require('../functions/valToNumber');\n\nvar omit = require('../functions/omit');\n\nvar objectHasKeys = require('../functions/objectHasKeys');\n\nvar isValidUserToken = require('../utils/isValidUserToken');\n\nvar RefinementList = require('./RefinementList');\n/**\n * isEqual, but only for numeric refinement values, possible values:\n * - 5\n * - [5]\n * - [[5]]\n * - [[5,5],[4]]\n */\n\n\nfunction isEqualNumericRefinement(a, b) {\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every(function (el, i) {\n      return isEqualNumericRefinement(b[i], el);\n    });\n  }\n\n  return a === b;\n}\n/**\n * like _.find but using deep equality to be able to use it\n * to find arrays.\n * @private\n * @param {any[]} array array to search into (elements are base or array of base)\n * @param {any} searchedValue the value we're looking for (base or array of base)\n * @return {any} the searched value or undefined\n */\n\n\nfunction findArray(array, searchedValue) {\n  return find(array, function (currentValue) {\n    return isEqualNumericRefinement(currentValue, searchedValue);\n  });\n}\n/**\n * The facet list is the structure used to store the list of values used to\n * filter a single attribute.\n * @typedef {string[]} SearchParameters.FacetList\n */\n\n/**\n * Structure to store numeric filters with the operator as the key. The supported operators\n * are `=`, `>`, `<`, `>=`, `<=` and `!=`.\n * @typedef {Object.<string, Array.<number|number[]>>} SearchParameters.OperatorList\n */\n\n/**\n * SearchParameters is the data structure that contains all the information\n * usable for making a search to Algolia API. It doesn't do the search itself,\n * nor does it contains logic about the parameters.\n * It is an immutable object, therefore it has been created in a way that each\n * changes does not change the object itself but returns a copy with the\n * modification.\n * This object should probably not be instantiated outside of the helper. It will\n * be provided when needed. This object is documented for reference as you'll\n * get it from events generated by the {@link AlgoliaSearchHelper}.\n * If need be, instantiate the Helper from the factory function {@link SearchParameters.make}\n * @constructor\n * @classdesc contains all the parameters of a search\n * @param {object|SearchParameters} newParameters existing parameters or partial object\n * for the properties of a new SearchParameters\n * @see SearchParameters.make\n * @example <caption>SearchParameters of the first query in\n *   <a href=\"http://demos.algolia.com/instant-search-demo/\">the instant search demo</a></caption>\n{\n   \"query\": \"\",\n   \"disjunctiveFacets\": [\n      \"customerReviewCount\",\n      \"category\",\n      \"salePrice_range\",\n      \"manufacturer\"\n  ],\n   \"maxValuesPerFacet\": 30,\n   \"page\": 0,\n   \"hitsPerPage\": 10,\n   \"facets\": [\n      \"type\",\n      \"shipping\"\n  ]\n}\n */\n\n\nfunction SearchParameters(newParameters) {\n  var params = newParameters ? SearchParameters._parseNumbers(newParameters) : {};\n\n  if (params.userToken !== undefined && !isValidUserToken(params.userToken)) {\n    console.warn('[algoliasearch-helper] The `userToken` parameter is invalid. This can lead to wrong analytics.\\n  - Format: [a-zA-Z0-9_-]{1,64}');\n  }\n  /**\n   * This attribute contains the list of all the conjunctive facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * @member {string[]}\n   */\n\n\n  this.facets = params.facets || [];\n  /**\n   * This attribute contains the list of all the disjunctive facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * @member {string[]}\n   */\n\n  this.disjunctiveFacets = params.disjunctiveFacets || [];\n  /**\n   * This attribute contains the list of all the hierarchical facets\n   * used. This list will be added to requested facets in the\n   * [facets attribute](https://www.algolia.com/doc/rest-api/search#param-facets) sent to algolia.\n   * Hierarchical facets are a sub type of disjunctive facets that\n   * let you filter faceted attributes hierarchically.\n   * @member {string[]|object[]}\n   */\n\n  this.hierarchicalFacets = params.hierarchicalFacets || []; // Refinements\n\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the conjunctive facets. Each facet must be properly\n   * defined in the `facets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n\n  this.facetsRefinements = params.facetsRefinements || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * excluded from the conjunctive facets. Each facet must be properly\n   * defined in the `facets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters excluded for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n\n  this.facetsExcludes = params.facetsExcludes || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the disjunctive facets. Each facet must be properly\n   * defined in the `disjunctiveFacets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n\n  this.disjunctiveFacetsRefinements = params.disjunctiveFacetsRefinements || {};\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the numeric attributes.\n   *\n   * The key is the name of the attribute, and the value is the\n   * filters to apply to this attribute.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `numericFilters` attribute.\n   * @member {Object.<string, SearchParameters.OperatorList>}\n   */\n\n  this.numericRefinements = params.numericRefinements || {};\n  /**\n   * This attribute contains all the tags used to refine the query.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `tagFilters` attribute.\n   * @member {string[]}\n   */\n\n  this.tagRefinements = params.tagRefinements || [];\n  /**\n   * This attribute contains all the filters that need to be\n   * applied on the hierarchical facets. Each facet must be properly\n   * defined in the `hierarchicalFacets` attribute.\n   *\n   * The key is the name of the facet, and the `FacetList` contains all\n   * filters selected for the associated facet name. The FacetList values\n   * are structured as a string that contain the values for each level\n   * separated by the configured separator.\n   *\n   * When querying algolia, the values stored in this attribute will\n   * be translated into the `facetFilters` attribute.\n   * @member {Object.<string, SearchParameters.FacetList>}\n   */\n\n  this.hierarchicalFacetsRefinements = params.hierarchicalFacetsRefinements || {};\n  var self = this;\n  Object.keys(params).forEach(function (paramName) {\n    var isKeyKnown = SearchParameters.PARAMETERS.indexOf(paramName) !== -1;\n    var isValueDefined = params[paramName] !== undefined;\n\n    if (!isKeyKnown && isValueDefined) {\n      self[paramName] = params[paramName];\n    }\n  });\n}\n/**\n * List all the properties in SearchParameters and therefore all the known Algolia properties\n * This doesn't contain any beta/hidden features.\n * @private\n */\n\n\nSearchParameters.PARAMETERS = Object.keys(new SearchParameters());\n/**\n * @private\n * @param {object} partialState full or part of a state\n * @return {object} a new object with the number keys as number\n */\n\nSearchParameters._parseNumbers = function (partialState) {\n  // Do not reparse numbers in SearchParameters, they ought to be parsed already\n  if (partialState instanceof SearchParameters) return partialState;\n  var numbers = {};\n  var numberKeys = ['aroundPrecision', 'aroundRadius', 'getRankingInfo', 'minWordSizefor2Typos', 'minWordSizefor1Typo', 'page', 'maxValuesPerFacet', 'distinct', 'minimumAroundRadius', 'hitsPerPage', 'minProximity'];\n  numberKeys.forEach(function (k) {\n    var value = partialState[k];\n\n    if (typeof value === 'string') {\n      var parsedValue = parseFloat(value); // global isNaN is ok to use here, value is only number or NaN\n\n      numbers[k] = isNaN(parsedValue) ? value : parsedValue;\n    }\n  }); // there's two formats of insideBoundingBox, we need to parse\n  // the one which is an array of float geo rectangles\n\n  if (Array.isArray(partialState.insideBoundingBox)) {\n    numbers.insideBoundingBox = partialState.insideBoundingBox.map(function (geoRect) {\n      if (Array.isArray(geoRect)) {\n        return geoRect.map(function (value) {\n          return parseFloat(value);\n        });\n      }\n\n      return geoRect;\n    });\n  }\n\n  if (partialState.numericRefinements) {\n    var numericRefinements = {};\n    Object.keys(partialState.numericRefinements).forEach(function (attribute) {\n      var operators = partialState.numericRefinements[attribute] || {};\n      numericRefinements[attribute] = {};\n      Object.keys(operators).forEach(function (operator) {\n        var values = operators[operator];\n        var parsedValues = values.map(function (v) {\n          if (Array.isArray(v)) {\n            return v.map(function (vPrime) {\n              if (typeof vPrime === 'string') {\n                return parseFloat(vPrime);\n              }\n\n              return vPrime;\n            });\n          } else if (typeof v === 'string') {\n            return parseFloat(v);\n          }\n\n          return v;\n        });\n        numericRefinements[attribute][operator] = parsedValues;\n      });\n    });\n    numbers.numericRefinements = numericRefinements;\n  }\n\n  return merge({}, partialState, numbers);\n};\n/**\n * Factory for SearchParameters\n * @param {object|SearchParameters} newParameters existing parameters or partial\n * object for the properties of a new SearchParameters\n * @return {SearchParameters} frozen instance of SearchParameters\n */\n\n\nSearchParameters.make = function makeSearchParameters(newParameters) {\n  var instance = new SearchParameters(newParameters);\n  var hierarchicalFacets = newParameters.hierarchicalFacets || [];\n  hierarchicalFacets.forEach(function (facet) {\n    if (facet.rootPath) {\n      var currentRefinement = instance.getHierarchicalRefinement(facet.name);\n\n      if (currentRefinement.length > 0 && currentRefinement[0].indexOf(facet.rootPath) !== 0) {\n        instance = instance.clearRefinements(facet.name);\n      } // get it again in case it has been cleared\n\n\n      currentRefinement = instance.getHierarchicalRefinement(facet.name);\n\n      if (currentRefinement.length === 0) {\n        instance = instance.toggleHierarchicalFacetRefinement(facet.name, facet.rootPath);\n      }\n    }\n  });\n  return instance;\n};\n/**\n * Validates the new parameters based on the previous state\n * @param {SearchParameters} currentState the current state\n * @param {object|SearchParameters} parameters the new parameters to set\n * @return {Error|null} Error if the modification is invalid, null otherwise\n */\n\n\nSearchParameters.validate = function (currentState, parameters) {\n  var params = parameters || {};\n\n  if (currentState.tagFilters && params.tagRefinements && params.tagRefinements.length > 0) {\n    return new Error('[Tags] Cannot switch from the managed tag API to the advanced API. It is probably ' + 'an error, if it is really what you want, you should first clear the tags with clearTags method.');\n  }\n\n  if (currentState.tagRefinements.length > 0 && params.tagFilters) {\n    return new Error('[Tags] Cannot switch from the advanced tag API to the managed API. It is probably ' + 'an error, if it is not, you should first clear the tags with clearTags method.');\n  }\n\n  if (currentState.numericFilters && params.numericRefinements && objectHasKeys(params.numericRefinements)) {\n    return new Error(\"[Numeric filters] Can't switch from the advanced to the managed API. It\" + ' is probably an error, if this is really what you want, you have to first' + ' clear the numeric filters.');\n  }\n\n  if (objectHasKeys(currentState.numericRefinements) && params.numericFilters) {\n    return new Error(\"[Numeric filters] Can't switch from the managed API to the advanced. It\" + ' is probably an error, if this is really what you want, you have to first' + ' clear the numeric filters.');\n  }\n\n  return null;\n};\n\nSearchParameters.prototype = {\n  constructor: SearchParameters,\n\n  /**\n   * Remove all refinements (disjunctive + conjunctive + excludes + numeric filters)\n   * @method\n   * @param {undefined|string|SearchParameters.clearCallback} [attribute] optional string or function\n   * - If not given, means to clear all the filters.\n   * - If `string`, means to clear all refinements for the `attribute` named filter.\n   * - If `function`, means to clear all the refinements that return truthy values.\n   * @return {SearchParameters}\n   */\n  clearRefinements: function clearRefinements(attribute) {\n    var patch = {\n      numericRefinements: this._clearNumericRefinements(attribute),\n      facetsRefinements: RefinementList.clearRefinement(this.facetsRefinements, attribute, 'conjunctiveFacet'),\n      facetsExcludes: RefinementList.clearRefinement(this.facetsExcludes, attribute, 'exclude'),\n      disjunctiveFacetsRefinements: RefinementList.clearRefinement(this.disjunctiveFacetsRefinements, attribute, 'disjunctiveFacet'),\n      hierarchicalFacetsRefinements: RefinementList.clearRefinement(this.hierarchicalFacetsRefinements, attribute, 'hierarchicalFacet')\n    };\n\n    if (patch.numericRefinements === this.numericRefinements && patch.facetsRefinements === this.facetsRefinements && patch.facetsExcludes === this.facetsExcludes && patch.disjunctiveFacetsRefinements === this.disjunctiveFacetsRefinements && patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements) {\n      return this;\n    }\n\n    return this.setQueryParameters(patch);\n  },\n\n  /**\n   * Remove all the refined tags from the SearchParameters\n   * @method\n   * @return {SearchParameters}\n   */\n  clearTags: function clearTags() {\n    if (this.tagFilters === undefined && this.tagRefinements.length === 0) return this;\n    return this.setQueryParameters({\n      tagFilters: undefined,\n      tagRefinements: []\n    });\n  },\n\n  /**\n   * Set the index.\n   * @method\n   * @param {string} index the index name\n   * @return {SearchParameters}\n   */\n  setIndex: function setIndex(index) {\n    if (index === this.index) return this;\n    return this.setQueryParameters({\n      index: index\n    });\n  },\n\n  /**\n   * Query setter\n   * @method\n   * @param {string} newQuery value for the new query\n   * @return {SearchParameters}\n   */\n  setQuery: function setQuery(newQuery) {\n    if (newQuery === this.query) return this;\n    return this.setQueryParameters({\n      query: newQuery\n    });\n  },\n\n  /**\n   * Page setter\n   * @method\n   * @param {number} newPage new page number\n   * @return {SearchParameters}\n   */\n  setPage: function setPage(newPage) {\n    if (newPage === this.page) return this;\n    return this.setQueryParameters({\n      page: newPage\n    });\n  },\n\n  /**\n   * Facets setter\n   * The facets are the simple facets, used for conjunctive (and) faceting.\n   * @method\n   * @param {string[]} facets all the attributes of the algolia records used for conjunctive faceting\n   * @return {SearchParameters}\n   */\n  setFacets: function setFacets(facets) {\n    return this.setQueryParameters({\n      facets: facets\n    });\n  },\n\n  /**\n   * Disjunctive facets setter\n   * Change the list of disjunctive (or) facets the helper chan handle.\n   * @method\n   * @param {string[]} facets all the attributes of the algolia records used for disjunctive faceting\n   * @return {SearchParameters}\n   */\n  setDisjunctiveFacets: function setDisjunctiveFacets(facets) {\n    return this.setQueryParameters({\n      disjunctiveFacets: facets\n    });\n  },\n\n  /**\n   * HitsPerPage setter\n   * Hits per page represents the number of hits retrieved for this query\n   * @method\n   * @param {number} n number of hits retrieved per page of results\n   * @return {SearchParameters}\n   */\n  setHitsPerPage: function setHitsPerPage(n) {\n    if (this.hitsPerPage === n) return this;\n    return this.setQueryParameters({\n      hitsPerPage: n\n    });\n  },\n\n  /**\n   * typoTolerance setter\n   * Set the value of typoTolerance\n   * @method\n   * @param {string} typoTolerance new value of typoTolerance (\"true\", \"false\", \"min\" or \"strict\")\n   * @return {SearchParameters}\n   */\n  setTypoTolerance: function setTypoTolerance(typoTolerance) {\n    if (this.typoTolerance === typoTolerance) return this;\n    return this.setQueryParameters({\n      typoTolerance: typoTolerance\n    });\n  },\n\n  /**\n   * Add a numeric filter for a given attribute\n   * When value is an array, they are combined with OR\n   * When value is a single value, it will combined with AND\n   * @method\n   * @param {string} attribute attribute to set the filter on\n   * @param {string} operator operator of the filter (possible values: =, >, >=, <, <=, !=)\n   * @param {number | number[]} value value of the filter\n   * @return {SearchParameters}\n   * @example\n   * // for price = 50 or 40\n   * searchparameter.addNumericRefinement('price', '=', [50, 40]);\n   * @example\n   * // for size = 38 and 40\n   * searchparameter.addNumericRefinement('size', '=', 38);\n   * searchparameter.addNumericRefinement('size', '=', 40);\n   */\n  addNumericRefinement: function addNumericRefinement(attribute, operator, v) {\n    var value = valToNumber(v);\n    if (this.isNumericRefined(attribute, operator, value)) return this;\n    var mod = merge({}, this.numericRefinements);\n    mod[attribute] = merge({}, mod[attribute]);\n\n    if (mod[attribute][operator]) {\n      // Array copy\n      mod[attribute][operator] = mod[attribute][operator].slice(); // Add the element. Concat can't be used here because value can be an array.\n\n      mod[attribute][operator].push(value);\n    } else {\n      mod[attribute][operator] = [value];\n    }\n\n    return this.setQueryParameters({\n      numericRefinements: mod\n    });\n  },\n\n  /**\n   * Get the list of conjunctive refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getConjunctiveRefinements: function getConjunctiveRefinements(facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      return [];\n    }\n\n    return this.facetsRefinements[facetName] || [];\n  },\n\n  /**\n   * Get the list of disjunctive refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getDisjunctiveRefinements: function getDisjunctiveRefinements(facetName) {\n    if (!this.isDisjunctiveFacet(facetName)) {\n      return [];\n    }\n\n    return this.disjunctiveFacetsRefinements[facetName] || [];\n  },\n\n  /**\n   * Get the list of hierarchical refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getHierarchicalRefinement: function getHierarchicalRefinement(facetName) {\n    // we send an array but we currently do not support multiple\n    // hierarchicalRefinements for a hierarchicalFacet\n    return this.hierarchicalFacetsRefinements[facetName] || [];\n  },\n\n  /**\n   * Get the list of exclude refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {string[]} list of refinements\n   */\n  getExcludeRefinements: function getExcludeRefinements(facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      return [];\n    }\n\n    return this.facetsExcludes[facetName] || [];\n  },\n\n  /**\n   * Remove all the numeric filter for a given (attribute, operator)\n   * @method\n   * @param {string} attribute attribute to set the filter on\n   * @param {string} [operator] operator of the filter (possible values: =, >, >=, <, <=, !=)\n   * @param {number} [number] the value to be removed\n   * @return {SearchParameters}\n   */\n  removeNumericRefinement: function removeNumericRefinement(attribute, operator, paramValue) {\n    if (paramValue !== undefined) {\n      if (!this.isNumericRefined(attribute, operator, paramValue)) {\n        return this;\n      }\n\n      return this.setQueryParameters({\n        numericRefinements: this._clearNumericRefinements(function (value, key) {\n          return key === attribute && value.op === operator && isEqualNumericRefinement(value.val, valToNumber(paramValue));\n        })\n      });\n    } else if (operator !== undefined) {\n      if (!this.isNumericRefined(attribute, operator)) return this;\n      return this.setQueryParameters({\n        numericRefinements: this._clearNumericRefinements(function (value, key) {\n          return key === attribute && value.op === operator;\n        })\n      });\n    }\n\n    if (!this.isNumericRefined(attribute)) return this;\n    return this.setQueryParameters({\n      numericRefinements: this._clearNumericRefinements(function (value, key) {\n        return key === attribute;\n      })\n    });\n  },\n\n  /**\n   * Get the list of numeric refinements for a single facet\n   * @param {string} facetName name of the attribute used for faceting\n   * @return {SearchParameters.OperatorList} list of refinements\n   */\n  getNumericRefinements: function getNumericRefinements(facetName) {\n    return this.numericRefinements[facetName] || {};\n  },\n\n  /**\n   * Return the current refinement for the (attribute, operator)\n   * @param {string} attribute attribute in the record\n   * @param {string} operator operator applied on the refined values\n   * @return {Array.<number|number[]>} refined values\n   */\n  getNumericRefinement: function getNumericRefinement(attribute, operator) {\n    return this.numericRefinements[attribute] && this.numericRefinements[attribute][operator];\n  },\n\n  /**\n   * Clear numeric filters.\n   * @method\n   * @private\n   * @param {string|SearchParameters.clearCallback} [attribute] optional string or function\n   * - If not given, means to clear all the filters.\n   * - If `string`, means to clear all refinements for the `attribute` named filter.\n   * - If `function`, means to clear all the refinements that return truthy values.\n   * @return {Object.<string, OperatorList>}\n   */\n  _clearNumericRefinements: function _clearNumericRefinements(attribute) {\n    if (attribute === undefined) {\n      if (!objectHasKeys(this.numericRefinements)) {\n        return this.numericRefinements;\n      }\n\n      return {};\n    } else if (typeof attribute === 'string') {\n      return omit(this.numericRefinements, [attribute]);\n    } else if (typeof attribute === 'function') {\n      var hasChanged = false;\n      var numericRefinements = this.numericRefinements;\n      var newNumericRefinements = Object.keys(numericRefinements).reduce(function (memo, key) {\n        var operators = numericRefinements[key];\n        var operatorList = {};\n        operators = operators || {};\n        Object.keys(operators).forEach(function (operator) {\n          var values = operators[operator] || [];\n          var outValues = [];\n          values.forEach(function (value) {\n            var predicateResult = attribute({\n              val: value,\n              op: operator\n            }, key, 'numeric');\n            if (!predicateResult) outValues.push(value);\n          });\n\n          if (outValues.length !== values.length) {\n            hasChanged = true;\n          }\n\n          operatorList[operator] = outValues;\n        });\n        memo[key] = operatorList;\n        return memo;\n      }, {});\n      if (hasChanged) return newNumericRefinements;\n      return this.numericRefinements;\n    }\n  },\n\n  /**\n   * Add a facet to the facets attribute of the helper configuration, if it\n   * isn't already present.\n   * @method\n   * @param {string} facet facet name to add\n   * @return {SearchParameters}\n   */\n  addFacet: function addFacet(facet) {\n    if (this.isConjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.setQueryParameters({\n      facets: this.facets.concat([facet])\n    });\n  },\n\n  /**\n   * Add a disjunctive facet to the disjunctiveFacets attribute of the helper\n   * configuration, if it isn't already present.\n   * @method\n   * @param {string} facet disjunctive facet name to add\n   * @return {SearchParameters}\n   */\n  addDisjunctiveFacet: function addDisjunctiveFacet(facet) {\n    if (this.isDisjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.setQueryParameters({\n      disjunctiveFacets: this.disjunctiveFacets.concat([facet])\n    });\n  },\n\n  /**\n   * Add a hierarchical facet to the hierarchicalFacets attribute of the helper\n   * configuration.\n   * @method\n   * @param {object} hierarchicalFacet hierarchical facet to add\n   * @return {SearchParameters}\n   * @throws will throw an error if a hierarchical facet with the same name was already declared\n   */\n  addHierarchicalFacet: function addHierarchicalFacet(hierarchicalFacet) {\n    if (this.isHierarchicalFacet(hierarchicalFacet.name)) {\n      throw new Error('Cannot declare two hierarchical facets with the same name: `' + hierarchicalFacet.name + '`');\n    }\n\n    return this.setQueryParameters({\n      hierarchicalFacets: this.hierarchicalFacets.concat([hierarchicalFacet])\n    });\n  },\n\n  /**\n   * Add a refinement on a \"normal\" facet\n   * @method\n   * @param {string} facet attribute to apply the faceting on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters}\n   */\n  addFacetRefinement: function addFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    if (RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.addRefinement(this.facetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Exclude a value from a \"normal\" facet\n   * @method\n   * @param {string} facet attribute to apply the exclusion on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters}\n   */\n  addExcludeRefinement: function addExcludeRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    if (RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.addRefinement(this.facetsExcludes, facet, value)\n    });\n  },\n\n  /**\n   * Adds a refinement on a disjunctive facet.\n   * @method\n   * @param {string} facet attribute to apply the faceting on\n   * @param {string} value value of the attribute (will be converted to string)\n   * @return {SearchParameters}\n   */\n  addDisjunctiveFacetRefinement: function addDisjunctiveFacetRefinement(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n\n    if (RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.addRefinement(this.disjunctiveFacetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * addTagRefinement adds a tag to the list used to filter the results\n   * @param {string} tag tag to be added\n   * @return {SearchParameters}\n   */\n  addTagRefinement: function addTagRefinement(tag) {\n    if (this.isTagRefined(tag)) return this;\n    var modification = {\n      tagRefinements: this.tagRefinements.concat(tag)\n    };\n    return this.setQueryParameters(modification);\n  },\n\n  /**\n   * Remove a facet from the facets attribute of the helper configuration, if it\n   * is present.\n   * @method\n   * @param {string} facet facet name to remove\n   * @return {SearchParameters}\n   */\n  removeFacet: function removeFacet(facet) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      facets: this.facets.filter(function (f) {\n        return f !== facet;\n      })\n    });\n  },\n\n  /**\n   * Remove a disjunctive facet from the disjunctiveFacets attribute of the\n   * helper configuration, if it is present.\n   * @method\n   * @param {string} facet disjunctive facet name to remove\n   * @return {SearchParameters}\n   */\n  removeDisjunctiveFacet: function removeDisjunctiveFacet(facet) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      disjunctiveFacets: this.disjunctiveFacets.filter(function (f) {\n        return f !== facet;\n      })\n    });\n  },\n\n  /**\n   * Remove a hierarchical facet from the hierarchicalFacets attribute of the\n   * helper configuration, if it is present.\n   * @method\n   * @param {string} facet hierarchical facet name to remove\n   * @return {SearchParameters}\n   */\n  removeHierarchicalFacet: function removeHierarchicalFacet(facet) {\n    if (!this.isHierarchicalFacet(facet)) {\n      return this;\n    }\n\n    return this.clearRefinements(facet).setQueryParameters({\n      hierarchicalFacets: this.hierarchicalFacets.filter(function (f) {\n        return f.name !== facet;\n      })\n    });\n  },\n\n  /**\n   * Remove a refinement set on facet. If a value is provided, it will clear the\n   * refinement for the given value, otherwise it will clear all the refinement\n   * values for the faceted attribute.\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} [value] value used to filter\n   * @return {SearchParameters}\n   */\n  removeFacetRefinement: function removeFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    if (!RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.removeRefinement(this.facetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Remove a negative refinement on a facet\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} value value used to filter\n   * @return {SearchParameters}\n   */\n  removeExcludeRefinement: function removeExcludeRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    if (!RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.removeRefinement(this.facetsExcludes, facet, value)\n    });\n  },\n\n  /**\n   * Remove a refinement on a disjunctive facet\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {string} value value used to filter\n   * @return {SearchParameters}\n   */\n  removeDisjunctiveFacetRefinement: function removeDisjunctiveFacetRefinement(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n\n    if (!RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.removeRefinement(this.disjunctiveFacetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Remove a tag from the list of tag refinements\n   * @method\n   * @param {string} tag the tag to remove\n   * @return {SearchParameters}\n   */\n  removeTagRefinement: function removeTagRefinement(tag) {\n    if (!this.isTagRefined(tag)) return this;\n    var modification = {\n      tagRefinements: this.tagRefinements.filter(function (t) {\n        return t !== tag;\n      })\n    };\n    return this.setQueryParameters(modification);\n  },\n\n  /**\n   * Generic toggle refinement method to use with facet, disjunctive facets\n   * and hierarchical facets\n   * @param  {string} facet the facet to refine\n   * @param  {string} value the associated value\n   * @return {SearchParameters}\n   * @throws will throw an error if the facet is not declared in the settings of the helper\n   * @deprecated since version 2.19.0, see {@link SearchParameters#toggleFacetRefinement}\n   */\n  toggleRefinement: function toggleRefinement(facet, value) {\n    return this.toggleFacetRefinement(facet, value);\n  },\n\n  /**\n   * Generic toggle refinement method to use with facet, disjunctive facets\n   * and hierarchical facets\n   * @param  {string} facet the facet to refine\n   * @param  {string} value the associated value\n   * @return {SearchParameters}\n   * @throws will throw an error if the facet is not declared in the settings of the helper\n   */\n  toggleFacetRefinement: function toggleFacetRefinement(facet, value) {\n    if (this.isHierarchicalFacet(facet)) {\n      return this.toggleHierarchicalFacetRefinement(facet, value);\n    } else if (this.isConjunctiveFacet(facet)) {\n      return this.toggleConjunctiveFacetRefinement(facet, value);\n    } else if (this.isDisjunctiveFacet(facet)) {\n      return this.toggleDisjunctiveFacetRefinement(facet, value);\n    }\n\n    throw new Error('Cannot refine the undeclared facet ' + facet + '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets');\n  },\n\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.toggleRefinement(this.facetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.toggleRefinement(this.facetsExcludes, facet, value)\n    });\n  },\n\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleDisjunctiveFacetRefinement: function toggleDisjunctiveFacetRefinement(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.toggleRefinement(this.disjunctiveFacetsRefinements, facet, value)\n    });\n  },\n\n  /**\n   * Switch the refinement applied over a facet/value\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {SearchParameters}\n   */\n  toggleHierarchicalFacetRefinement: function toggleHierarchicalFacetRefinement(facet, value) {\n    if (!this.isHierarchicalFacet(facet)) {\n      throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration');\n    }\n\n    var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facet));\n\n    var mod = {};\n    var upOneOrMultipleLevel = this.hierarchicalFacetsRefinements[facet] !== undefined && this.hierarchicalFacetsRefinements[facet].length > 0 && ( // remove current refinement:\n    // refinement was 'beer > IPA', call is toggleRefine('beer > IPA'), refinement should be `beer`\n    this.hierarchicalFacetsRefinements[facet][0] === value || // remove a parent refinement of the current refinement:\n    //  - refinement was 'beer > IPA > Flying dog'\n    //  - call is toggleRefine('beer > IPA')\n    //  - refinement should be `beer`\n    this.hierarchicalFacetsRefinements[facet][0].indexOf(value + separator) === 0);\n\n    if (upOneOrMultipleLevel) {\n      if (value.indexOf(separator) === -1) {\n        // go back to root level\n        mod[facet] = [];\n      } else {\n        mod[facet] = [value.slice(0, value.lastIndexOf(separator))];\n      }\n    } else {\n      mod[facet] = [value];\n    }\n\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)\n    });\n  },\n\n  /**\n   * Adds a refinement on a hierarchical facet.\n   * @param {string} facet the facet name\n   * @param {string} path the hierarchical facet path\n   * @return {SearchParameter} the new state\n   * @throws Error if the facet is not defined or if the facet is refined\n   */\n  addHierarchicalFacetRefinement: function addHierarchicalFacetRefinement(facet, path) {\n    if (this.isHierarchicalFacetRefined(facet)) {\n      throw new Error(facet + ' is already refined.');\n    }\n\n    if (!this.isHierarchicalFacet(facet)) {\n      throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration.');\n    }\n\n    var mod = {};\n    mod[facet] = [path];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)\n    });\n  },\n\n  /**\n   * Removes the refinement set on a hierarchical facet.\n   * @param {string} facet the facet name\n   * @return {SearchParameter} the new state\n   * @throws Error if the facet is not defined or if the facet is not refined\n   */\n  removeHierarchicalFacetRefinement: function removeHierarchicalFacetRefinement(facet) {\n    if (!this.isHierarchicalFacetRefined(facet)) {\n      return this;\n    }\n\n    var mod = {};\n    mod[facet] = [];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)\n    });\n  },\n\n  /**\n   * Switch the tag refinement\n   * @method\n   * @param {string} tag the tag to remove or add\n   * @return {SearchParameters}\n   */\n  toggleTagRefinement: function toggleTagRefinement(tag) {\n    if (this.isTagRefined(tag)) {\n      return this.removeTagRefinement(tag);\n    }\n\n    return this.addTagRefinement(tag);\n  },\n\n  /**\n   * Test if the facet name is from one of the disjunctive facets\n   * @method\n   * @param {string} facet facet name to test\n   * @return {boolean}\n   */\n  isDisjunctiveFacet: function isDisjunctiveFacet(facet) {\n    return this.disjunctiveFacets.indexOf(facet) > -1;\n  },\n\n  /**\n   * Test if the facet name is from one of the hierarchical facets\n   * @method\n   * @param {string} facetName facet name to test\n   * @return {boolean}\n   */\n  isHierarchicalFacet: function isHierarchicalFacet(facetName) {\n    return this.getHierarchicalFacetByName(facetName) !== undefined;\n  },\n\n  /**\n   * Test if the facet name is from one of the conjunctive/normal facets\n   * @method\n   * @param {string} facet facet name to test\n   * @return {boolean}\n   */\n  isConjunctiveFacet: function isConjunctiveFacet(facet) {\n    return this.facets.indexOf(facet) > -1;\n  },\n\n  /**\n   * Returns true if the facet is refined, either for a specific value or in\n   * general.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value, optional value. If passed will test that this value\n   * is filtering the given facet.\n   * @return {boolean} returns true if refined\n   */\n  isFacetRefined: function isFacetRefined(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return false;\n    }\n\n    return RefinementList.isRefined(this.facetsRefinements, facet, value);\n  },\n\n  /**\n   * Returns true if the facet contains exclusions or if a specific value is\n   * excluded.\n   *\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} [value] optional value. If passed will test that this value\n   * is filtering the given facet.\n   * @return {boolean} returns true if refined\n   */\n  isExcludeRefined: function isExcludeRefined(facet, value) {\n    if (!this.isConjunctiveFacet(facet)) {\n      return false;\n    }\n\n    return RefinementList.isRefined(this.facetsExcludes, facet, value);\n  },\n\n  /**\n   * Returns true if the facet contains a refinement, or if a value passed is a\n   * refinement for the facet.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value optional, will test if the value is used for refinement\n   * if there is one, otherwise will test if the facet contains any refinement\n   * @return {boolean}\n   */\n  isDisjunctiveFacetRefined: function isDisjunctiveFacetRefined(facet, value) {\n    if (!this.isDisjunctiveFacet(facet)) {\n      return false;\n    }\n\n    return RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value);\n  },\n\n  /**\n   * Returns true if the facet contains a refinement, or if a value passed is a\n   * refinement for the facet.\n   * @method\n   * @param {string} facet name of the attribute for used for faceting\n   * @param {string} value optional, will test if the value is used for refinement\n   * if there is one, otherwise will test if the facet contains any refinement\n   * @return {boolean}\n   */\n  isHierarchicalFacetRefined: function isHierarchicalFacetRefined(facet, value) {\n    if (!this.isHierarchicalFacet(facet)) {\n      return false;\n    }\n\n    var refinements = this.getHierarchicalRefinement(facet);\n\n    if (!value) {\n      return refinements.length > 0;\n    }\n\n    return refinements.indexOf(value) !== -1;\n  },\n\n  /**\n   * Test if the triple (attribute, operator, value) is already refined.\n   * If only the attribute and the operator are provided, it tests if the\n   * contains any refinement value.\n   * @method\n   * @param {string} attribute attribute for which the refinement is applied\n   * @param {string} [operator] operator of the refinement\n   * @param {string} [value] value of the refinement\n   * @return {boolean} true if it is refined\n   */\n  isNumericRefined: function isNumericRefined(attribute, operator, value) {\n    if (value === undefined && operator === undefined) {\n      return !!this.numericRefinements[attribute];\n    }\n\n    var isOperatorDefined = this.numericRefinements[attribute] && this.numericRefinements[attribute][operator] !== undefined;\n\n    if (value === undefined || !isOperatorDefined) {\n      return isOperatorDefined;\n    }\n\n    var parsedValue = valToNumber(value);\n    var isAttributeValueDefined = findArray(this.numericRefinements[attribute][operator], parsedValue) !== undefined;\n    return isOperatorDefined && isAttributeValueDefined;\n  },\n\n  /**\n   * Returns true if the tag refined, false otherwise\n   * @method\n   * @param {string} tag the tag to check\n   * @return {boolean}\n   */\n  isTagRefined: function isTagRefined(tag) {\n    return this.tagRefinements.indexOf(tag) !== -1;\n  },\n\n  /**\n   * Returns the list of all disjunctive facets refined\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {string[]}\n   */\n  getRefinedDisjunctiveFacets: function getRefinedDisjunctiveFacets() {\n    var self = this; // attributes used for numeric filter can also be disjunctive\n\n    var disjunctiveNumericRefinedFacets = intersection(Object.keys(this.numericRefinements).filter(function (facet) {\n      return Object.keys(self.numericRefinements[facet]).length > 0;\n    }), this.disjunctiveFacets);\n    return Object.keys(this.disjunctiveFacetsRefinements).filter(function (facet) {\n      return self.disjunctiveFacetsRefinements[facet].length > 0;\n    }).concat(disjunctiveNumericRefinedFacets).concat(this.getRefinedHierarchicalFacets());\n  },\n\n  /**\n   * Returns the list of all disjunctive facets refined\n   * @method\n   * @param {string} facet name of the attribute used for faceting\n   * @param {value} value value used for filtering\n   * @return {string[]}\n   */\n  getRefinedHierarchicalFacets: function getRefinedHierarchicalFacets() {\n    var self = this;\n    return intersection( // enforce the order between the two arrays,\n    // so that refinement name index === hierarchical facet index\n    this.hierarchicalFacets.map(function (facet) {\n      return facet.name;\n    }), Object.keys(this.hierarchicalFacetsRefinements).filter(function (facet) {\n      return self.hierarchicalFacetsRefinements[facet].length > 0;\n    }));\n  },\n\n  /**\n   * Returned the list of all disjunctive facets not refined\n   * @method\n   * @return {string[]}\n   */\n  getUnrefinedDisjunctiveFacets: function getUnrefinedDisjunctiveFacets() {\n    var refinedFacets = this.getRefinedDisjunctiveFacets();\n    return this.disjunctiveFacets.filter(function (f) {\n      return refinedFacets.indexOf(f) === -1;\n    });\n  },\n  managedParameters: ['index', 'facets', 'disjunctiveFacets', 'facetsRefinements', 'facetsExcludes', 'disjunctiveFacetsRefinements', 'numericRefinements', 'tagRefinements', 'hierarchicalFacets', 'hierarchicalFacetsRefinements'],\n  getQueryParams: function getQueryParams() {\n    var managedParameters = this.managedParameters;\n    var queryParams = {};\n    var self = this;\n    Object.keys(this).forEach(function (paramName) {\n      var paramValue = self[paramName];\n\n      if (managedParameters.indexOf(paramName) === -1 && paramValue !== undefined) {\n        queryParams[paramName] = paramValue;\n      }\n    });\n    return queryParams;\n  },\n\n  /**\n   * Let the user set a specific value for a given parameter. Will return the\n   * same instance if the parameter is invalid or if the value is the same as the\n   * previous one.\n   * @method\n   * @param {string} parameter the parameter name\n   * @param {any} value the value to be set, must be compliant with the definition\n   * of the attribute on the object\n   * @return {SearchParameters} the updated state\n   */\n  setQueryParameter: function setParameter(parameter, value) {\n    if (this[parameter] === value) return this;\n    var modification = {};\n    modification[parameter] = value;\n    return this.setQueryParameters(modification);\n  },\n\n  /**\n   * Let the user set any of the parameters with a plain object.\n   * @method\n   * @param {object} params all the keys and the values to be updated\n   * @return {SearchParameters} a new updated instance\n   */\n  setQueryParameters: function setQueryParameters(params) {\n    if (!params) return this;\n    var error = SearchParameters.validate(this, params);\n\n    if (error) {\n      throw error;\n    }\n\n    var self = this;\n\n    var nextWithNumbers = SearchParameters._parseNumbers(params);\n\n    var previousPlainObject = Object.keys(this).reduce(function (acc, key) {\n      acc[key] = self[key];\n      return acc;\n    }, {});\n    var nextPlainObject = Object.keys(nextWithNumbers).reduce(function (previous, key) {\n      var isPreviousValueDefined = previous[key] !== undefined;\n      var isNextValueDefined = nextWithNumbers[key] !== undefined;\n\n      if (isPreviousValueDefined && !isNextValueDefined) {\n        return omit(previous, [key]);\n      }\n\n      if (isNextValueDefined) {\n        previous[key] = nextWithNumbers[key];\n      }\n\n      return previous;\n    }, previousPlainObject);\n    return new this.constructor(nextPlainObject);\n  },\n\n  /**\n   * Returns a new instance with the page reset. Two scenarios possible:\n   * the page is omitted -> return the given instance\n   * the page is set -> return a new instance with a page of 0\n   * @return {SearchParameters} a new updated instance\n   */\n  resetPage: function resetPage() {\n    if (this.page === undefined) {\n      return this;\n    }\n\n    return this.setPage(0);\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet separator or the default one (`>`)\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.separator or `>` as default\n   */\n  _getHierarchicalFacetSortBy: function _getHierarchicalFacetSortBy(hierarchicalFacet) {\n    return hierarchicalFacet.sortBy || ['isRefined:desc', 'name:asc'];\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet separator or the default one (`>`)\n   * @private\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.separator or `>` as default\n   */\n  _getHierarchicalFacetSeparator: function _getHierarchicalFacetSeparator(hierarchicalFacet) {\n    return hierarchicalFacet.separator || ' > ';\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet prefix path or null\n   * @private\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.rootPath or null as default\n   */\n  _getHierarchicalRootPath: function _getHierarchicalRootPath(hierarchicalFacet) {\n    return hierarchicalFacet.rootPath || null;\n  },\n\n  /**\n   * Helper function to check if we show the parent level of the hierarchicalFacet\n   * @private\n   * @param  {object} hierarchicalFacet\n   * @return {string} returns the hierarchicalFacet.showParentLevel or true as default\n   */\n  _getHierarchicalShowParentLevel: function _getHierarchicalShowParentLevel(hierarchicalFacet) {\n    if (typeof hierarchicalFacet.showParentLevel === 'boolean') {\n      return hierarchicalFacet.showParentLevel;\n    }\n\n    return true;\n  },\n\n  /**\n   * Helper function to get the hierarchicalFacet by it's name\n   * @param  {string} hierarchicalFacetName\n   * @return {object} a hierarchicalFacet\n   */\n  getHierarchicalFacetByName: function getHierarchicalFacetByName(hierarchicalFacetName) {\n    return find(this.hierarchicalFacets, function (f) {\n      return f.name === hierarchicalFacetName;\n    });\n  },\n\n  /**\n   * Get the current breadcrumb for a hierarchical facet, as an array\n   * @param  {string} facetName Hierarchical facet name\n   * @return {array.<string>} the path as an array of string\n   */\n  getHierarchicalFacetBreadcrumb: function getHierarchicalFacetBreadcrumb(facetName) {\n    if (!this.isHierarchicalFacet(facetName)) {\n      return [];\n    }\n\n    var refinement = this.getHierarchicalRefinement(facetName)[0];\n    if (!refinement) return [];\n\n    var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facetName));\n\n    var path = refinement.split(separator);\n    return path.map(function (part) {\n      return part.trim();\n    });\n  },\n  toString: function toString() {\n    return JSON.stringify(this, null, 2);\n  }\n};\n/**\n * Callback used for clearRefinement method\n * @callback SearchParameters.clearCallback\n * @param {OperatorList|FacetList} value the value of the filter\n * @param {string} key the current attribute name\n * @param {string} type `numeric`, `disjunctiveFacet`, `conjunctiveFacet`, `hierarchicalFacet` or `exclude`\n * depending on the type of facet\n * @return {boolean} `true` if the element should be removed. `false` otherwise.\n */\n\nmodule.exports = SearchParameters;","'use strict';\n\nfunction intersection(arr1, arr2) {\n  return arr1.filter(function (value, index) {\n    return arr2.indexOf(value) > -1 && arr1.indexOf(value) === index\n    /* skips duplicates */\n    ;\n  });\n}\n\nmodule.exports = intersection;","'use strict';\n\nmodule.exports = function isValidUserToken(userToken) {\n  if (userToken === null) {\n    return false;\n  }\n\n  return /^[a-zA-Z0-9_-]{1,64}$/.test(userToken);\n};","'use strict';\n\nmodule.exports = function compact(array) {\n  if (!Array.isArray(array)) {\n    return [];\n  }\n\n  return array.filter(Boolean);\n};","/* global Map:readonly, Set:readonly, ArrayBuffer:readonly */\nvar hasElementType = typeof Element !== 'undefined';\nvar hasMap = typeof Map === 'function';\nvar hasSet = typeof Set === 'function';\nvar hasArrayBuffer = typeof ArrayBuffer === 'function' && !!ArrayBuffer.isView; // Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js\n\nfunction equal(a, b) {\n  // START: fast-deep-equal es6/index.js 3.1.1\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n    var length, i, keys;\n\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n\n      for (i = length; i-- !== 0;) {\n        if (!equal(a[i], b[i])) return false;\n      }\n\n      return true;\n    } // START: Modifications:\n    // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code\n    //    to co-exist with es5.\n    // 2. Replace `for of` with es5 compliant iteration using `for`.\n    //    Basically, take:\n    //\n    //    ```js\n    //    for (i of a.entries())\n    //      if (!b.has(i[0])) return false;\n    //    ```\n    //\n    //    ... and convert to:\n    //\n    //    ```js\n    //    it = a.entries();\n    //    while (!(i = it.next()).done)\n    //      if (!b.has(i.value[0])) return false;\n    //    ```\n    //\n    //    **Note**: `i` access switches to `i.value`.\n\n\n    var it;\n\n    if (hasMap && a instanceof Map && b instanceof Map) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n\n      while (!(i = it.next()).done) {\n        if (!b.has(i.value[0])) return false;\n      }\n\n      it = a.entries();\n\n      while (!(i = it.next()).done) {\n        if (!equal(i.value[1], b.get(i.value[0]))) return false;\n      }\n\n      return true;\n    }\n\n    if (hasSet && a instanceof Set && b instanceof Set) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n\n      while (!(i = it.next()).done) {\n        if (!b.has(i.value[0])) return false;\n      }\n\n      return true;\n    } // END: Modifications\n\n\n    if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n\n      for (i = length; i-- !== 0;) {\n        if (a[i] !== b[i]) return false;\n      }\n\n      return true;\n    }\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;) {\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n    } // END: fast-deep-equal\n    // START: react-fast-compare\n    // custom handling for DOM elements\n\n\n    if (hasElementType && a instanceof Element) return false; // custom handling for React/Preact\n\n    for (i = length; i-- !== 0;) {\n      if ((keys[i] === '_owner' || keys[i] === '__v' || keys[i] === '__o') && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner\n        // Preact-specific: avoid traversing Preact elements' __v and __o\n        //    __v = $_original / $_vnode\n        //    __o = $_owner\n        // These properties contain circular references and are not needed when\n        // comparing the actual elements (and not their owners)\n        // .$$typeof and ._store on just reasonable markers of elements\n        continue;\n      } // all other properties should be traversed as usual\n\n\n      if (!equal(a[keys[i]], b[keys[i]])) return false;\n    } // END: react-fast-compare\n    // START: fast-deep-equal\n\n\n    return true;\n  }\n\n  return a !== a && b !== b;\n} // end fast-deep-equal\n\n\nmodule.exports = function isEqual(a, b) {\n  try {\n    return equal(a, b);\n  } catch (error) {\n    if ((error.message || '').match(/stack|recursion/i)) {\n      // warn on circular references, don't crash\n      // browsers give this different errors name and messages:\n      // chrome/safari: \"RangeError\", \"Maximum call stack size exceeded\"\n      // firefox: \"InternalError\", too much recursion\"\n      // edge: \"Error\", \"Out of stack space\"\n      console.warn('react-fast-compare cannot handle circular refs');\n      return false;\n    } // some other error. we should definitely know about these\n\n\n    throw error;\n  }\n};","'use strict';\n\nfunction objectHasKeys(obj) {\n  return obj && Object.keys(obj).length > 0;\n}\n\nmodule.exports = objectHasKeys;","'use strict'; // NOTE: this behaves like lodash/defaults, but doesn't mutate the target\n// it also preserve keys order\n\nrequire(\"core-js/modules/es.array.reduce-right.js\");\n\nmodule.exports = function defaultsPure() {\n  var sources = Array.prototype.slice.call(arguments);\n  return sources.reduceRight(function (acc, source) {\n    Object.keys(Object(source)).forEach(function (key) {\n      if (source[key] === undefined) {\n        return;\n      }\n\n      if (acc[key] !== undefined) {\n        // remove if already added, so that we can add it in correct order\n        delete acc[key];\n      }\n\n      acc[key] = source[key];\n    });\n    return acc;\n  }, {});\n};","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nmodule.exports = generateTrees;\n\nvar orderBy = require('../functions/orderBy');\n\nvar find = require('../functions/find');\n\nvar prepareHierarchicalFacetSortBy = require('../functions/formatSort');\n\nfunction generateTrees(state) {\n  return function generate(hierarchicalFacetResult, hierarchicalFacetIndex) {\n    var hierarchicalFacet = state.hierarchicalFacets[hierarchicalFacetIndex];\n    var hierarchicalFacetRefinement = state.hierarchicalFacetsRefinements[hierarchicalFacet.name] && state.hierarchicalFacetsRefinements[hierarchicalFacet.name][0] || '';\n\n    var hierarchicalSeparator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n    var hierarchicalRootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n\n    var hierarchicalShowParentLevel = state._getHierarchicalShowParentLevel(hierarchicalFacet);\n\n    var sortBy = prepareHierarchicalFacetSortBy(state._getHierarchicalFacetSortBy(hierarchicalFacet));\n    var rootExhaustive = hierarchicalFacetResult.every(function (facetResult) {\n      return facetResult.exhaustive;\n    });\n    var generateTreeFn = generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, hierarchicalFacetRefinement);\n    var results = hierarchicalFacetResult;\n\n    if (hierarchicalRootPath) {\n      results = hierarchicalFacetResult.slice(hierarchicalRootPath.split(hierarchicalSeparator).length);\n    }\n\n    return results.reduce(generateTreeFn, {\n      name: state.hierarchicalFacets[hierarchicalFacetIndex].name,\n      count: null,\n      // root level, no count\n      isRefined: true,\n      // root level, always refined\n      path: null,\n      // root level, no path\n      exhaustive: rootExhaustive,\n      data: null\n    });\n  };\n}\n\nfunction generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, currentRefinement) {\n  return function generateTree(hierarchicalTree, hierarchicalFacetResult, currentHierarchicalLevel) {\n    var parent = hierarchicalTree;\n\n    if (currentHierarchicalLevel > 0) {\n      var level = 0;\n      parent = hierarchicalTree;\n\n      while (level < currentHierarchicalLevel) {\n        /**\n         * @type {object[]]} hierarchical data\n         */\n        var data = parent && Array.isArray(parent.data) ? parent.data : [];\n        parent = find(data, function (subtree) {\n          return subtree.isRefined;\n        });\n        level++;\n      }\n    } // we found a refined parent, let's add current level data under it\n\n\n    if (parent) {\n      // filter values in case an object has multiple categories:\n      //   {\n      //     categories: {\n      //       level0: ['beers', 'bières'],\n      //       level1: ['beers > IPA', 'bières > Belges']\n      //     }\n      //   }\n      //\n      // If parent refinement is `beers`, then we do not want to have `bières > Belges`\n      // showing up\n      var picked = Object.keys(hierarchicalFacetResult.data).map(function (facetValue) {\n        return [facetValue, hierarchicalFacetResult.data[facetValue]];\n      }).filter(function (tuple) {\n        var facetValue = tuple[0];\n        return onlyMatchingTree(facetValue, parent.path || hierarchicalRootPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel);\n      });\n      parent.data = orderBy(picked.map(function (tuple) {\n        var facetValue = tuple[0];\n        var facetCount = tuple[1];\n        return format(facetCount, facetValue, hierarchicalSeparator, currentRefinement, hierarchicalFacetResult.exhaustive);\n      }), sortBy[0], sortBy[1]);\n    }\n\n    return hierarchicalTree;\n  };\n}\n\nfunction onlyMatchingTree(facetValue, parentPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel) {\n  // we want the facetValue is a child of hierarchicalRootPath\n  if (hierarchicalRootPath && (facetValue.indexOf(hierarchicalRootPath) !== 0 || hierarchicalRootPath === facetValue)) {\n    return false;\n  } // we always want root levels (only when there is no prefix path)\n\n\n  return !hierarchicalRootPath && facetValue.indexOf(hierarchicalSeparator) === -1 || // if there is a rootPath, being root level mean 1 level under rootPath\n  hierarchicalRootPath && facetValue.split(hierarchicalSeparator).length - hierarchicalRootPath.split(hierarchicalSeparator).length === 1 || // if current refinement is a root level and current facetValue is a root level,\n  // keep the facetValue\n  facetValue.indexOf(hierarchicalSeparator) === -1 && currentRefinement.indexOf(hierarchicalSeparator) === -1 || // currentRefinement is a child of the facet value\n  currentRefinement.indexOf(facetValue) === 0 || // facetValue is a child of the current parent, add it\n  facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 && (hierarchicalShowParentLevel || facetValue.indexOf(currentRefinement) === 0);\n}\n\nfunction format(facetCount, facetValue, hierarchicalSeparator, currentRefinement, exhaustive) {\n  var parts = facetValue.split(hierarchicalSeparator);\n  return {\n    name: parts[parts.length - 1].trim(),\n    path: facetValue,\n    count: facetCount,\n    isRefined: currentRefinement === facetValue || currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,\n    exhaustive: exhaustive,\n    data: null\n  };\n}","'use strict';\n\nfunction valToNumber(v) {\n  if (typeof v === 'number') {\n    return v;\n  } else if (typeof v === 'string') {\n    return parseFloat(v);\n  } else if (Array.isArray(v)) {\n    return v.map(valToNumber);\n  }\n\n  throw new Error('The value should be a number, a parsable string or an array of those.');\n}\n\nmodule.exports = valToNumber;","'use strict'; // @MAJOR can be replaced by native Array#findIndex when we change support\n\nmodule.exports = function find(array, comparator) {\n  if (!Array.isArray(array)) {\n    return -1;\n  }\n\n  for (var i = 0; i < array.length; i++) {\n    if (comparator(array[i])) {\n      return i;\n    }\n  }\n\n  return -1;\n};","'use strict'; // https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source === null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key;\n  var i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nmodule.exports = _objectWithoutPropertiesLoose;","import \"core-js/modules/es.array.reduce.js\";\nimport PropTypes from 'prop-types';\nimport withSideEffect from 'react-side-effect';\nimport isEqual from 'react-fast-compare';\nimport React from 'react';\nimport objectAssign from 'object-assign';\nvar ATTRIBUTE_NAMES = {\n  BODY: \"bodyAttributes\",\n  HTML: \"htmlAttributes\",\n  TITLE: \"titleAttributes\"\n};\nvar TAG_NAMES = {\n  BASE: \"base\",\n  BODY: \"body\",\n  HEAD: \"head\",\n  HTML: \"html\",\n  LINK: \"link\",\n  META: \"meta\",\n  NOSCRIPT: \"noscript\",\n  SCRIPT: \"script\",\n  STYLE: \"style\",\n  TITLE: \"title\"\n};\nvar VALID_TAG_NAMES = Object.keys(TAG_NAMES).map(function (name) {\n  return TAG_NAMES[name];\n});\nvar TAG_PROPERTIES = {\n  CHARSET: \"charset\",\n  CSS_TEXT: \"cssText\",\n  HREF: \"href\",\n  HTTPEQUIV: \"http-equiv\",\n  INNER_HTML: \"innerHTML\",\n  ITEM_PROP: \"itemprop\",\n  NAME: \"name\",\n  PROPERTY: \"property\",\n  REL: \"rel\",\n  SRC: \"src\",\n  TARGET: \"target\"\n};\nvar REACT_TAG_MAP = {\n  accesskey: \"accessKey\",\n  charset: \"charSet\",\n  class: \"className\",\n  contenteditable: \"contentEditable\",\n  contextmenu: \"contextMenu\",\n  \"http-equiv\": \"httpEquiv\",\n  itemprop: \"itemProp\",\n  tabindex: \"tabIndex\"\n};\nvar HELMET_PROPS = {\n  DEFAULT_TITLE: \"defaultTitle\",\n  DEFER: \"defer\",\n  ENCODE_SPECIAL_CHARACTERS: \"encodeSpecialCharacters\",\n  ON_CHANGE_CLIENT_STATE: \"onChangeClientState\",\n  TITLE_TEMPLATE: \"titleTemplate\"\n};\nvar HTML_TAG_MAP = Object.keys(REACT_TAG_MAP).reduce(function (obj, key) {\n  obj[REACT_TAG_MAP[key]] = key;\n  return obj;\n}, {});\nvar SELF_CLOSING_TAGS = [TAG_NAMES.NOSCRIPT, TAG_NAMES.SCRIPT, TAG_NAMES.STYLE];\nvar HELMET_ATTRIBUTE = \"data-react-helmet\";\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar classCallCheck = function classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar inherits = function inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar objectWithoutProperties = function objectWithoutProperties(obj, keys) {\n  var target = {};\n\n  for (var i in obj) {\n    if (keys.indexOf(i) >= 0) continue;\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;\n    target[i] = obj[i];\n  }\n\n  return target;\n};\n\nvar possibleConstructorReturn = function possibleConstructorReturn(self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\n\nvar encodeSpecialCharacters = function encodeSpecialCharacters(str) {\n  var encode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n  if (encode === false) {\n    return String(str);\n  }\n\n  return String(str).replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\").replace(/\"/g, \"&quot;\").replace(/'/g, \"&#x27;\");\n};\n\nvar getTitleFromPropsList = function getTitleFromPropsList(propsList) {\n  var innermostTitle = getInnermostProperty(propsList, TAG_NAMES.TITLE);\n  var innermostTemplate = getInnermostProperty(propsList, HELMET_PROPS.TITLE_TEMPLATE);\n\n  if (innermostTemplate && innermostTitle) {\n    // use function arg to avoid need to escape $ characters\n    return innermostTemplate.replace(/%s/g, function () {\n      return Array.isArray(innermostTitle) ? innermostTitle.join(\"\") : innermostTitle;\n    });\n  }\n\n  var innermostDefaultTitle = getInnermostProperty(propsList, HELMET_PROPS.DEFAULT_TITLE);\n  return innermostTitle || innermostDefaultTitle || undefined;\n};\n\nvar getOnChangeClientState = function getOnChangeClientState(propsList) {\n  return getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || function () {};\n};\n\nvar getAttributesFromPropsList = function getAttributesFromPropsList(tagType, propsList) {\n  return propsList.filter(function (props) {\n    return typeof props[tagType] !== \"undefined\";\n  }).map(function (props) {\n    return props[tagType];\n  }).reduce(function (tagAttrs, current) {\n    return _extends({}, tagAttrs, current);\n  }, {});\n};\n\nvar getBaseTagFromPropsList = function getBaseTagFromPropsList(primaryAttributes, propsList) {\n  return propsList.filter(function (props) {\n    return typeof props[TAG_NAMES.BASE] !== \"undefined\";\n  }).map(function (props) {\n    return props[TAG_NAMES.BASE];\n  }).reverse().reduce(function (innermostBaseTag, tag) {\n    if (!innermostBaseTag.length) {\n      var keys = Object.keys(tag);\n\n      for (var i = 0; i < keys.length; i++) {\n        var attributeKey = keys[i];\n        var lowerCaseAttributeKey = attributeKey.toLowerCase();\n\n        if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && tag[lowerCaseAttributeKey]) {\n          return innermostBaseTag.concat(tag);\n        }\n      }\n    }\n\n    return innermostBaseTag;\n  }, []);\n};\n\nvar getTagsFromPropsList = function getTagsFromPropsList(tagName, primaryAttributes, propsList) {\n  // Calculate list of tags, giving priority innermost component (end of the propslist)\n  var approvedSeenTags = {};\n  return propsList.filter(function (props) {\n    if (Array.isArray(props[tagName])) {\n      return true;\n    }\n\n    if (typeof props[tagName] !== \"undefined\") {\n      warn(\"Helmet: \" + tagName + \" should be of type \\\"Array\\\". Instead found type \\\"\" + _typeof(props[tagName]) + \"\\\"\");\n    }\n\n    return false;\n  }).map(function (props) {\n    return props[tagName];\n  }).reverse().reduce(function (approvedTags, instanceTags) {\n    var instanceSeenTags = {};\n    instanceTags.filter(function (tag) {\n      var primaryAttributeKey = void 0;\n      var keys = Object.keys(tag);\n\n      for (var i = 0; i < keys.length; i++) {\n        var attributeKey = keys[i];\n        var lowerCaseAttributeKey = attributeKey.toLowerCase(); // Special rule with link tags, since rel and href are both primary tags, rel takes priority\n\n        if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === TAG_PROPERTIES.REL && tag[primaryAttributeKey].toLowerCase() === \"canonical\") && !(lowerCaseAttributeKey === TAG_PROPERTIES.REL && tag[lowerCaseAttributeKey].toLowerCase() === \"stylesheet\")) {\n          primaryAttributeKey = lowerCaseAttributeKey;\n        } // Special case for innerHTML which doesn't work lowercased\n\n\n        if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === TAG_PROPERTIES.INNER_HTML || attributeKey === TAG_PROPERTIES.CSS_TEXT || attributeKey === TAG_PROPERTIES.ITEM_PROP)) {\n          primaryAttributeKey = attributeKey;\n        }\n      }\n\n      if (!primaryAttributeKey || !tag[primaryAttributeKey]) {\n        return false;\n      }\n\n      var value = tag[primaryAttributeKey].toLowerCase();\n\n      if (!approvedSeenTags[primaryAttributeKey]) {\n        approvedSeenTags[primaryAttributeKey] = {};\n      }\n\n      if (!instanceSeenTags[primaryAttributeKey]) {\n        instanceSeenTags[primaryAttributeKey] = {};\n      }\n\n      if (!approvedSeenTags[primaryAttributeKey][value]) {\n        instanceSeenTags[primaryAttributeKey][value] = true;\n        return true;\n      }\n\n      return false;\n    }).reverse().forEach(function (tag) {\n      return approvedTags.push(tag);\n    }); // Update seen tags with tags from this instance\n\n    var keys = Object.keys(instanceSeenTags);\n\n    for (var i = 0; i < keys.length; i++) {\n      var attributeKey = keys[i];\n      var tagUnion = objectAssign({}, approvedSeenTags[attributeKey], instanceSeenTags[attributeKey]);\n      approvedSeenTags[attributeKey] = tagUnion;\n    }\n\n    return approvedTags;\n  }, []).reverse();\n};\n\nvar getInnermostProperty = function getInnermostProperty(propsList, property) {\n  for (var i = propsList.length - 1; i >= 0; i--) {\n    var props = propsList[i];\n\n    if (props.hasOwnProperty(property)) {\n      return props[property];\n    }\n  }\n\n  return null;\n};\n\nvar reducePropsToState = function reducePropsToState(propsList) {\n  return {\n    baseTag: getBaseTagFromPropsList([TAG_PROPERTIES.HREF, TAG_PROPERTIES.TARGET], propsList),\n    bodyAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.BODY, propsList),\n    defer: getInnermostProperty(propsList, HELMET_PROPS.DEFER),\n    encode: getInnermostProperty(propsList, HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),\n    htmlAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.HTML, propsList),\n    linkTags: getTagsFromPropsList(TAG_NAMES.LINK, [TAG_PROPERTIES.REL, TAG_PROPERTIES.HREF], propsList),\n    metaTags: getTagsFromPropsList(TAG_NAMES.META, [TAG_PROPERTIES.NAME, TAG_PROPERTIES.CHARSET, TAG_PROPERTIES.HTTPEQUIV, TAG_PROPERTIES.PROPERTY, TAG_PROPERTIES.ITEM_PROP], propsList),\n    noscriptTags: getTagsFromPropsList(TAG_NAMES.NOSCRIPT, [TAG_PROPERTIES.INNER_HTML], propsList),\n    onChangeClientState: getOnChangeClientState(propsList),\n    scriptTags: getTagsFromPropsList(TAG_NAMES.SCRIPT, [TAG_PROPERTIES.SRC, TAG_PROPERTIES.INNER_HTML], propsList),\n    styleTags: getTagsFromPropsList(TAG_NAMES.STYLE, [TAG_PROPERTIES.CSS_TEXT], propsList),\n    title: getTitleFromPropsList(propsList),\n    titleAttributes: getAttributesFromPropsList(ATTRIBUTE_NAMES.TITLE, propsList)\n  };\n};\n\nvar rafPolyfill = function () {\n  var clock = Date.now();\n  return function (callback) {\n    var currentTime = Date.now();\n\n    if (currentTime - clock > 16) {\n      clock = currentTime;\n      callback(currentTime);\n    } else {\n      setTimeout(function () {\n        rafPolyfill(callback);\n      }, 0);\n    }\n  };\n}();\n\nvar cafPolyfill = function cafPolyfill(id) {\n  return clearTimeout(id);\n};\n\nvar requestAnimationFrame = typeof window !== \"undefined\" ? window.requestAnimationFrame && window.requestAnimationFrame.bind(window) || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || rafPolyfill : global.requestAnimationFrame || rafPolyfill;\nvar cancelAnimationFrame = typeof window !== \"undefined\" ? window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || cafPolyfill : global.cancelAnimationFrame || cafPolyfill;\n\nvar warn = function warn(msg) {\n  return console && typeof console.warn === \"function\" && console.warn(msg);\n};\n\nvar _helmetCallback = null;\n\nvar handleClientStateChange = function handleClientStateChange(newState) {\n  if (_helmetCallback) {\n    cancelAnimationFrame(_helmetCallback);\n  }\n\n  if (newState.defer) {\n    _helmetCallback = requestAnimationFrame(function () {\n      commitTagChanges(newState, function () {\n        _helmetCallback = null;\n      });\n    });\n  } else {\n    commitTagChanges(newState);\n    _helmetCallback = null;\n  }\n};\n\nvar commitTagChanges = function commitTagChanges(newState, cb) {\n  var baseTag = newState.baseTag,\n      bodyAttributes = newState.bodyAttributes,\n      htmlAttributes = newState.htmlAttributes,\n      linkTags = newState.linkTags,\n      metaTags = newState.metaTags,\n      noscriptTags = newState.noscriptTags,\n      onChangeClientState = newState.onChangeClientState,\n      scriptTags = newState.scriptTags,\n      styleTags = newState.styleTags,\n      title = newState.title,\n      titleAttributes = newState.titleAttributes;\n  updateAttributes(TAG_NAMES.BODY, bodyAttributes);\n  updateAttributes(TAG_NAMES.HTML, htmlAttributes);\n  updateTitle(title, titleAttributes);\n  var tagUpdates = {\n    baseTag: updateTags(TAG_NAMES.BASE, baseTag),\n    linkTags: updateTags(TAG_NAMES.LINK, linkTags),\n    metaTags: updateTags(TAG_NAMES.META, metaTags),\n    noscriptTags: updateTags(TAG_NAMES.NOSCRIPT, noscriptTags),\n    scriptTags: updateTags(TAG_NAMES.SCRIPT, scriptTags),\n    styleTags: updateTags(TAG_NAMES.STYLE, styleTags)\n  };\n  var addedTags = {};\n  var removedTags = {};\n  Object.keys(tagUpdates).forEach(function (tagType) {\n    var _tagUpdates$tagType = tagUpdates[tagType],\n        newTags = _tagUpdates$tagType.newTags,\n        oldTags = _tagUpdates$tagType.oldTags;\n\n    if (newTags.length) {\n      addedTags[tagType] = newTags;\n    }\n\n    if (oldTags.length) {\n      removedTags[tagType] = tagUpdates[tagType].oldTags;\n    }\n  });\n  cb && cb();\n  onChangeClientState(newState, addedTags, removedTags);\n};\n\nvar flattenArray = function flattenArray(possibleArray) {\n  return Array.isArray(possibleArray) ? possibleArray.join(\"\") : possibleArray;\n};\n\nvar updateTitle = function updateTitle(title, attributes) {\n  if (typeof title !== \"undefined\" && document.title !== title) {\n    document.title = flattenArray(title);\n  }\n\n  updateAttributes(TAG_NAMES.TITLE, attributes);\n};\n\nvar updateAttributes = function updateAttributes(tagName, attributes) {\n  var elementTag = document.getElementsByTagName(tagName)[0];\n\n  if (!elementTag) {\n    return;\n  }\n\n  var helmetAttributeString = elementTag.getAttribute(HELMET_ATTRIBUTE);\n  var helmetAttributes = helmetAttributeString ? helmetAttributeString.split(\",\") : [];\n  var attributesToRemove = [].concat(helmetAttributes);\n  var attributeKeys = Object.keys(attributes);\n\n  for (var i = 0; i < attributeKeys.length; i++) {\n    var attribute = attributeKeys[i];\n    var value = attributes[attribute] || \"\";\n\n    if (elementTag.getAttribute(attribute) !== value) {\n      elementTag.setAttribute(attribute, value);\n    }\n\n    if (helmetAttributes.indexOf(attribute) === -1) {\n      helmetAttributes.push(attribute);\n    }\n\n    var indexToSave = attributesToRemove.indexOf(attribute);\n\n    if (indexToSave !== -1) {\n      attributesToRemove.splice(indexToSave, 1);\n    }\n  }\n\n  for (var _i = attributesToRemove.length - 1; _i >= 0; _i--) {\n    elementTag.removeAttribute(attributesToRemove[_i]);\n  }\n\n  if (helmetAttributes.length === attributesToRemove.length) {\n    elementTag.removeAttribute(HELMET_ATTRIBUTE);\n  } else if (elementTag.getAttribute(HELMET_ATTRIBUTE) !== attributeKeys.join(\",\")) {\n    elementTag.setAttribute(HELMET_ATTRIBUTE, attributeKeys.join(\",\"));\n  }\n};\n\nvar updateTags = function updateTags(type, tags) {\n  var headElement = document.head || document.querySelector(TAG_NAMES.HEAD);\n  var tagNodes = headElement.querySelectorAll(type + \"[\" + HELMET_ATTRIBUTE + \"]\");\n  var oldTags = Array.prototype.slice.call(tagNodes);\n  var newTags = [];\n  var indexToDelete = void 0;\n\n  if (tags && tags.length) {\n    tags.forEach(function (tag) {\n      var newElement = document.createElement(type);\n\n      for (var attribute in tag) {\n        if (tag.hasOwnProperty(attribute)) {\n          if (attribute === TAG_PROPERTIES.INNER_HTML) {\n            newElement.innerHTML = tag.innerHTML;\n          } else if (attribute === TAG_PROPERTIES.CSS_TEXT) {\n            if (newElement.styleSheet) {\n              newElement.styleSheet.cssText = tag.cssText;\n            } else {\n              newElement.appendChild(document.createTextNode(tag.cssText));\n            }\n          } else {\n            var value = typeof tag[attribute] === \"undefined\" ? \"\" : tag[attribute];\n            newElement.setAttribute(attribute, value);\n          }\n        }\n      }\n\n      newElement.setAttribute(HELMET_ATTRIBUTE, \"true\"); // Remove a duplicate tag from domTagstoRemove, so it isn't cleared.\n\n      if (oldTags.some(function (existingTag, index) {\n        indexToDelete = index;\n        return newElement.isEqualNode(existingTag);\n      })) {\n        oldTags.splice(indexToDelete, 1);\n      } else {\n        newTags.push(newElement);\n      }\n    });\n  }\n\n  oldTags.forEach(function (tag) {\n    return tag.parentNode.removeChild(tag);\n  });\n  newTags.forEach(function (tag) {\n    return headElement.appendChild(tag);\n  });\n  return {\n    oldTags: oldTags,\n    newTags: newTags\n  };\n};\n\nvar generateElementAttributesAsString = function generateElementAttributesAsString(attributes) {\n  return Object.keys(attributes).reduce(function (str, key) {\n    var attr = typeof attributes[key] !== \"undefined\" ? key + \"=\\\"\" + attributes[key] + \"\\\"\" : \"\" + key;\n    return str ? str + \" \" + attr : attr;\n  }, \"\");\n};\n\nvar generateTitleAsString = function generateTitleAsString(type, title, attributes, encode) {\n  var attributeString = generateElementAttributesAsString(attributes);\n  var flattenedTitle = flattenArray(title);\n  return attributeString ? \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\" \" + attributeString + \">\" + encodeSpecialCharacters(flattenedTitle, encode) + \"</\" + type + \">\" : \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\">\" + encodeSpecialCharacters(flattenedTitle, encode) + \"</\" + type + \">\";\n};\n\nvar generateTagsAsString = function generateTagsAsString(type, tags, encode) {\n  return tags.reduce(function (str, tag) {\n    var attributeHtml = Object.keys(tag).filter(function (attribute) {\n      return !(attribute === TAG_PROPERTIES.INNER_HTML || attribute === TAG_PROPERTIES.CSS_TEXT);\n    }).reduce(function (string, attribute) {\n      var attr = typeof tag[attribute] === \"undefined\" ? attribute : attribute + \"=\\\"\" + encodeSpecialCharacters(tag[attribute], encode) + \"\\\"\";\n      return string ? string + \" \" + attr : attr;\n    }, \"\");\n    var tagContent = tag.innerHTML || tag.cssText || \"\";\n    var isSelfClosing = SELF_CLOSING_TAGS.indexOf(type) === -1;\n    return str + \"<\" + type + \" \" + HELMET_ATTRIBUTE + \"=\\\"true\\\" \" + attributeHtml + (isSelfClosing ? \"/>\" : \">\" + tagContent + \"</\" + type + \">\");\n  }, \"\");\n};\n\nvar convertElementAttributestoReactProps = function convertElementAttributestoReactProps(attributes) {\n  var initProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return Object.keys(attributes).reduce(function (obj, key) {\n    obj[REACT_TAG_MAP[key] || key] = attributes[key];\n    return obj;\n  }, initProps);\n};\n\nvar convertReactPropstoHtmlAttributes = function convertReactPropstoHtmlAttributes(props) {\n  var initAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return Object.keys(props).reduce(function (obj, key) {\n    obj[HTML_TAG_MAP[key] || key] = props[key];\n    return obj;\n  }, initAttributes);\n};\n\nvar generateTitleAsReactComponent = function generateTitleAsReactComponent(type, title, attributes) {\n  var _initProps; // assigning into an array to define toString function on it\n\n\n  var initProps = (_initProps = {\n    key: title\n  }, _initProps[HELMET_ATTRIBUTE] = true, _initProps);\n  var props = convertElementAttributestoReactProps(attributes, initProps);\n  return [React.createElement(TAG_NAMES.TITLE, props, title)];\n};\n\nvar generateTagsAsReactComponent = function generateTagsAsReactComponent(type, tags) {\n  return tags.map(function (tag, i) {\n    var _mappedTag;\n\n    var mappedTag = (_mappedTag = {\n      key: i\n    }, _mappedTag[HELMET_ATTRIBUTE] = true, _mappedTag);\n    Object.keys(tag).forEach(function (attribute) {\n      var mappedAttribute = REACT_TAG_MAP[attribute] || attribute;\n\n      if (mappedAttribute === TAG_PROPERTIES.INNER_HTML || mappedAttribute === TAG_PROPERTIES.CSS_TEXT) {\n        var content = tag.innerHTML || tag.cssText;\n        mappedTag.dangerouslySetInnerHTML = {\n          __html: content\n        };\n      } else {\n        mappedTag[mappedAttribute] = tag[attribute];\n      }\n    });\n    return React.createElement(type, mappedTag);\n  });\n};\n\nvar getMethodsForTag = function getMethodsForTag(type, tags, encode) {\n  switch (type) {\n    case TAG_NAMES.TITLE:\n      return {\n        toComponent: function toComponent() {\n          return generateTitleAsReactComponent(type, tags.title, tags.titleAttributes, encode);\n        },\n        toString: function toString() {\n          return generateTitleAsString(type, tags.title, tags.titleAttributes, encode);\n        }\n      };\n\n    case ATTRIBUTE_NAMES.BODY:\n    case ATTRIBUTE_NAMES.HTML:\n      return {\n        toComponent: function toComponent() {\n          return convertElementAttributestoReactProps(tags);\n        },\n        toString: function toString() {\n          return generateElementAttributesAsString(tags);\n        }\n      };\n\n    default:\n      return {\n        toComponent: function toComponent() {\n          return generateTagsAsReactComponent(type, tags);\n        },\n        toString: function toString() {\n          return generateTagsAsString(type, tags, encode);\n        }\n      };\n  }\n};\n\nvar mapStateOnServer = function mapStateOnServer(_ref) {\n  var baseTag = _ref.baseTag,\n      bodyAttributes = _ref.bodyAttributes,\n      encode = _ref.encode,\n      htmlAttributes = _ref.htmlAttributes,\n      linkTags = _ref.linkTags,\n      metaTags = _ref.metaTags,\n      noscriptTags = _ref.noscriptTags,\n      scriptTags = _ref.scriptTags,\n      styleTags = _ref.styleTags,\n      _ref$title = _ref.title,\n      title = _ref$title === undefined ? \"\" : _ref$title,\n      titleAttributes = _ref.titleAttributes;\n  return {\n    base: getMethodsForTag(TAG_NAMES.BASE, baseTag, encode),\n    bodyAttributes: getMethodsForTag(ATTRIBUTE_NAMES.BODY, bodyAttributes, encode),\n    htmlAttributes: getMethodsForTag(ATTRIBUTE_NAMES.HTML, htmlAttributes, encode),\n    link: getMethodsForTag(TAG_NAMES.LINK, linkTags, encode),\n    meta: getMethodsForTag(TAG_NAMES.META, metaTags, encode),\n    noscript: getMethodsForTag(TAG_NAMES.NOSCRIPT, noscriptTags, encode),\n    script: getMethodsForTag(TAG_NAMES.SCRIPT, scriptTags, encode),\n    style: getMethodsForTag(TAG_NAMES.STYLE, styleTags, encode),\n    title: getMethodsForTag(TAG_NAMES.TITLE, {\n      title: title,\n      titleAttributes: titleAttributes\n    }, encode)\n  };\n};\n\nvar Helmet = function Helmet(Component) {\n  var _class, _temp;\n\n  return _temp = _class = function (_React$Component) {\n    inherits(HelmetWrapper, _React$Component);\n\n    function HelmetWrapper() {\n      classCallCheck(this, HelmetWrapper);\n      return possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n    }\n\n    HelmetWrapper.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n      return !isEqual(this.props, nextProps);\n    };\n\n    HelmetWrapper.prototype.mapNestedChildrenToProps = function mapNestedChildrenToProps(child, nestedChildren) {\n      if (!nestedChildren) {\n        return null;\n      }\n\n      switch (child.type) {\n        case TAG_NAMES.SCRIPT:\n        case TAG_NAMES.NOSCRIPT:\n          return {\n            innerHTML: nestedChildren\n          };\n\n        case TAG_NAMES.STYLE:\n          return {\n            cssText: nestedChildren\n          };\n      }\n\n      throw new Error(\"<\" + child.type + \" /> elements are self-closing and can not contain children. Refer to our API for more information.\");\n    };\n\n    HelmetWrapper.prototype.flattenArrayTypeChildren = function flattenArrayTypeChildren(_ref) {\n      var _babelHelpers$extends;\n\n      var child = _ref.child,\n          arrayTypeChildren = _ref.arrayTypeChildren,\n          newChildProps = _ref.newChildProps,\n          nestedChildren = _ref.nestedChildren;\n      return _extends({}, arrayTypeChildren, (_babelHelpers$extends = {}, _babelHelpers$extends[child.type] = [].concat(arrayTypeChildren[child.type] || [], [_extends({}, newChildProps, this.mapNestedChildrenToProps(child, nestedChildren))]), _babelHelpers$extends));\n    };\n\n    HelmetWrapper.prototype.mapObjectTypeChildren = function mapObjectTypeChildren(_ref2) {\n      var _babelHelpers$extends2, _babelHelpers$extends3;\n\n      var child = _ref2.child,\n          newProps = _ref2.newProps,\n          newChildProps = _ref2.newChildProps,\n          nestedChildren = _ref2.nestedChildren;\n\n      switch (child.type) {\n        case TAG_NAMES.TITLE:\n          return _extends({}, newProps, (_babelHelpers$extends2 = {}, _babelHelpers$extends2[child.type] = nestedChildren, _babelHelpers$extends2.titleAttributes = _extends({}, newChildProps), _babelHelpers$extends2));\n\n        case TAG_NAMES.BODY:\n          return _extends({}, newProps, {\n            bodyAttributes: _extends({}, newChildProps)\n          });\n\n        case TAG_NAMES.HTML:\n          return _extends({}, newProps, {\n            htmlAttributes: _extends({}, newChildProps)\n          });\n      }\n\n      return _extends({}, newProps, (_babelHelpers$extends3 = {}, _babelHelpers$extends3[child.type] = _extends({}, newChildProps), _babelHelpers$extends3));\n    };\n\n    HelmetWrapper.prototype.mapArrayTypeChildrenToProps = function mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {\n      var newFlattenedProps = _extends({}, newProps);\n\n      Object.keys(arrayTypeChildren).forEach(function (arrayChildName) {\n        var _babelHelpers$extends4;\n\n        newFlattenedProps = _extends({}, newFlattenedProps, (_babelHelpers$extends4 = {}, _babelHelpers$extends4[arrayChildName] = arrayTypeChildren[arrayChildName], _babelHelpers$extends4));\n      });\n      return newFlattenedProps;\n    };\n\n    HelmetWrapper.prototype.warnOnInvalidChildren = function warnOnInvalidChildren(child, nestedChildren) {\n      if (process.env.NODE_ENV !== \"production\") {\n        if (!VALID_TAG_NAMES.some(function (name) {\n          return child.type === name;\n        })) {\n          if (typeof child.type === \"function\") {\n            return warn(\"You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.\");\n          }\n\n          return warn(\"Only elements types \" + VALID_TAG_NAMES.join(\", \") + \" are allowed. Helmet does not support rendering <\" + child.type + \"> elements. Refer to our API for more information.\");\n        }\n\n        if (nestedChildren && typeof nestedChildren !== \"string\" && (!Array.isArray(nestedChildren) || nestedChildren.some(function (nestedChild) {\n          return typeof nestedChild !== \"string\";\n        }))) {\n          throw new Error(\"Helmet expects a string as a child of <\" + child.type + \">. Did you forget to wrap your children in braces? ( <\" + child.type + \">{``}</\" + child.type + \"> ) Refer to our API for more information.\");\n        }\n      }\n\n      return true;\n    };\n\n    HelmetWrapper.prototype.mapChildrenToProps = function mapChildrenToProps(children, newProps) {\n      var _this2 = this;\n\n      var arrayTypeChildren = {};\n      React.Children.forEach(children, function (child) {\n        if (!child || !child.props) {\n          return;\n        }\n\n        var _child$props = child.props,\n            nestedChildren = _child$props.children,\n            childProps = objectWithoutProperties(_child$props, [\"children\"]);\n        var newChildProps = convertReactPropstoHtmlAttributes(childProps);\n\n        _this2.warnOnInvalidChildren(child, nestedChildren);\n\n        switch (child.type) {\n          case TAG_NAMES.LINK:\n          case TAG_NAMES.META:\n          case TAG_NAMES.NOSCRIPT:\n          case TAG_NAMES.SCRIPT:\n          case TAG_NAMES.STYLE:\n            arrayTypeChildren = _this2.flattenArrayTypeChildren({\n              child: child,\n              arrayTypeChildren: arrayTypeChildren,\n              newChildProps: newChildProps,\n              nestedChildren: nestedChildren\n            });\n            break;\n\n          default:\n            newProps = _this2.mapObjectTypeChildren({\n              child: child,\n              newProps: newProps,\n              newChildProps: newChildProps,\n              nestedChildren: nestedChildren\n            });\n            break;\n        }\n      });\n      newProps = this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);\n      return newProps;\n    };\n\n    HelmetWrapper.prototype.render = function render() {\n      var _props = this.props,\n          children = _props.children,\n          props = objectWithoutProperties(_props, [\"children\"]);\n\n      var newProps = _extends({}, props);\n\n      if (children) {\n        newProps = this.mapChildrenToProps(children, newProps);\n      }\n\n      return React.createElement(Component, newProps);\n    };\n\n    createClass(HelmetWrapper, null, [{\n      key: \"canUseDOM\",\n      // Component.peek comes from react-side-effect:\n      // For testing, you may use a static peek() method available on the returned component.\n      // It lets you get the current state without resetting the mounted instance stack.\n      // Don’t use it for anything other than testing.\n\n      /**\n       * @param {Object} base: {\"target\": \"_blank\", \"href\": \"http://mysite.com/\"}\n       * @param {Object} bodyAttributes: {\"className\": \"root\"}\n       * @param {String} defaultTitle: \"Default Title\"\n       * @param {Boolean} defer: true\n       * @param {Boolean} encodeSpecialCharacters: true\n       * @param {Object} htmlAttributes: {\"lang\": \"en\", \"amp\": undefined}\n       * @param {Array} link: [{\"rel\": \"canonical\", \"href\": \"http://mysite.com/example\"}]\n       * @param {Array} meta: [{\"name\": \"description\", \"content\": \"Test description\"}]\n       * @param {Array} noscript: [{\"innerHTML\": \"<img src='http://mysite.com/js/test.js'\"}]\n       * @param {Function} onChangeClientState: \"(newState) => console.log(newState)\"\n       * @param {Array} script: [{\"type\": \"text/javascript\", \"src\": \"http://mysite.com/js/test.js\"}]\n       * @param {Array} style: [{\"type\": \"text/css\", \"cssText\": \"div { display: block; color: blue; }\"}]\n       * @param {String} title: \"Title\"\n       * @param {Object} titleAttributes: {\"itemprop\": \"name\"}\n       * @param {String} titleTemplate: \"MySite.com - %s\"\n       */\n      set: function set$$1(canUseDOM) {\n        Component.canUseDOM = canUseDOM;\n      }\n    }]);\n    return HelmetWrapper;\n  }(React.Component), _class.propTypes = {\n    base: PropTypes.object,\n    bodyAttributes: PropTypes.object,\n    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),\n    defaultTitle: PropTypes.string,\n    defer: PropTypes.bool,\n    encodeSpecialCharacters: PropTypes.bool,\n    htmlAttributes: PropTypes.object,\n    link: PropTypes.arrayOf(PropTypes.object),\n    meta: PropTypes.arrayOf(PropTypes.object),\n    noscript: PropTypes.arrayOf(PropTypes.object),\n    onChangeClientState: PropTypes.func,\n    script: PropTypes.arrayOf(PropTypes.object),\n    style: PropTypes.arrayOf(PropTypes.object),\n    title: PropTypes.string,\n    titleAttributes: PropTypes.object,\n    titleTemplate: PropTypes.string\n  }, _class.defaultProps = {\n    defer: true,\n    encodeSpecialCharacters: true\n  }, _class.peek = Component.peek, _class.rewind = function () {\n    var mappedState = Component.rewind();\n\n    if (!mappedState) {\n      // provide fallback if mappedState is undefined\n      mappedState = mapStateOnServer({\n        baseTag: [],\n        bodyAttributes: {},\n        encodeSpecialCharacters: true,\n        htmlAttributes: {},\n        linkTags: [],\n        metaTags: [],\n        noscriptTags: [],\n        scriptTags: [],\n        styleTags: [],\n        title: \"\",\n        titleAttributes: {}\n      });\n    }\n\n    return mappedState;\n  }, _temp;\n};\n\nvar NullComponent = function NullComponent() {\n  return null;\n};\n\nvar HelmetSideEffects = withSideEffect(reducePropsToState, handleClientStateChange, mapStateOnServer)(NullComponent);\nvar HelmetExport = Helmet(HelmetSideEffects);\nHelmetExport.renderStatic = HelmetExport.rewind;\nexport default HelmetExport;\nexport { HelmetExport as Helmet };","'use strict';\n\nrequire(\"core-js/modules/es.array.reduce.js\");\n\nvar merge = require('../functions/merge');\n\nvar defaultsPure = require('../functions/defaultsPure');\n\nvar orderBy = require('../functions/orderBy');\n\nvar compact = require('../functions/compact');\n\nvar find = require('../functions/find');\n\nvar findIndex = require('../functions/findIndex');\n\nvar formatSort = require('../functions/formatSort');\n\nvar generateHierarchicalTree = require('./generate-hierarchical-tree');\n/**\n * @typedef SearchResults.Facet\n * @type {object}\n * @property {string} name name of the attribute in the record\n * @property {object} data the faceting data: value, number of entries\n * @property {object} stats undefined unless facet_stats is retrieved from algolia\n */\n\n/**\n * @typedef SearchResults.HierarchicalFacet\n * @type {object}\n * @property {string} name name of the current value given the hierarchical level, trimmed.\n * If root node, you get the facet name\n * @property {number} count number of objects matching this hierarchical value\n * @property {string} path the current hierarchical value full path\n * @property {boolean} isRefined `true` if the current value was refined, `false` otherwise\n * @property {HierarchicalFacet[]} data sub values for the current level\n */\n\n/**\n * @typedef SearchResults.FacetValue\n * @type {object}\n * @property {string} name the facet value itself\n * @property {number} count times this facet appears in the results\n * @property {boolean} isRefined is the facet currently selected\n * @property {boolean} isExcluded is the facet currently excluded (only for conjunctive facets)\n */\n\n/**\n * @typedef Refinement\n * @type {object}\n * @property {string} type the type of filter used:\n * `numeric`, `facet`, `exclude`, `disjunctive`, `hierarchical`\n * @property {string} attributeName name of the attribute used for filtering\n * @property {string} name the value of the filter\n * @property {number} numericValue the value as a number. Only for numeric filters.\n * @property {string} operator the operator used. Only for numeric filters.\n * @property {number} count the number of computed hits for this filter. Only on facets.\n * @property {boolean} exhaustive if the count is exhaustive\n */\n\n/**\n * @param {string[]} attributes\n */\n\n\nfunction getIndices(attributes) {\n  var indices = {};\n  attributes.forEach(function (val, idx) {\n    indices[val] = idx;\n  });\n  return indices;\n}\n\nfunction assignFacetStats(dest, facetStats, key) {\n  if (facetStats && facetStats[key]) {\n    dest.stats = facetStats[key];\n  }\n}\n/**\n * @typedef {Object} HierarchicalFacet\n * @property {string} name\n * @property {string[]} attributes\n */\n\n/**\n * @param {HierarchicalFacet[]} hierarchicalFacets\n * @param {string} hierarchicalAttributeName\n */\n\n\nfunction findMatchingHierarchicalFacetFromAttributeName(hierarchicalFacets, hierarchicalAttributeName) {\n  return find(hierarchicalFacets, function facetKeyMatchesAttribute(hierarchicalFacet) {\n    var facetNames = hierarchicalFacet.attributes || [];\n    return facetNames.indexOf(hierarchicalAttributeName) > -1;\n  });\n}\n/*eslint-disable */\n\n/**\n * Constructor for SearchResults\n * @class\n * @classdesc SearchResults contains the results of a query to Algolia using the\n * {@link AlgoliaSearchHelper}.\n * @param {SearchParameters} state state that led to the response\n * @param {array.<object>} results the results from algolia client\n * @example <caption>SearchResults of the first query in\n * <a href=\"http://demos.algolia.com/instant-search-demo\">the instant search demo</a></caption>\n{\n   \"hitsPerPage\": 10,\n   \"processingTimeMS\": 2,\n   \"facets\": [\n      {\n         \"name\": \"type\",\n         \"data\": {\n            \"HardGood\": 6627,\n            \"BlackTie\": 550,\n            \"Music\": 665,\n            \"Software\": 131,\n            \"Game\": 456,\n            \"Movie\": 1571\n         },\n         \"exhaustive\": false\n      },\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"Free shipping\": 5507\n         },\n         \"name\": \"shipping\"\n      }\n  ],\n   \"hits\": [\n      {\n         \"thumbnailImage\": \"http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_54x108_s.gif\",\n         \"_highlightResult\": {\n            \"shortDescription\": {\n               \"matchLevel\": \"none\",\n               \"value\": \"Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection\",\n               \"matchedWords\": []\n            },\n            \"category\": {\n               \"matchLevel\": \"none\",\n               \"value\": \"Computer Security Software\",\n               \"matchedWords\": []\n            },\n            \"manufacturer\": {\n               \"matchedWords\": [],\n               \"value\": \"Webroot\",\n               \"matchLevel\": \"none\"\n            },\n            \"name\": {\n               \"value\": \"Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows\",\n               \"matchedWords\": [],\n               \"matchLevel\": \"none\"\n            }\n         },\n         \"image\": \"http://img.bbystatic.com/BestBuy_US/images/products/1688/1688832_105x210_sc.jpg\",\n         \"shipping\": \"Free shipping\",\n         \"bestSellingRank\": 4,\n         \"shortDescription\": \"Safeguard your PC, Mac, Android and iOS devices with comprehensive Internet protection\",\n         \"url\": \"http://www.bestbuy.com/site/webroot-secureanywhere-internet-security-3-devi…d=1219060687969&skuId=1688832&cmp=RMX&ky=2d3GfEmNIzjA0vkzveHdZEBgpPCyMnLTJ\",\n         \"name\": \"Webroot SecureAnywhere Internet Security (3-Device) (1-Year Subscription) - Mac/Windows\",\n         \"category\": \"Computer Security Software\",\n         \"salePrice_range\": \"1 - 50\",\n         \"objectID\": \"1688832\",\n         \"type\": \"Software\",\n         \"customerReviewCount\": 5980,\n         \"salePrice\": 49.99,\n         \"manufacturer\": \"Webroot\"\n      },\n      ....\n  ],\n   \"nbHits\": 10000,\n   \"disjunctiveFacets\": [\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"5\": 183,\n            \"12\": 112,\n            \"7\": 149,\n            ...\n         },\n         \"name\": \"customerReviewCount\",\n         \"stats\": {\n            \"max\": 7461,\n            \"avg\": 157.939,\n            \"min\": 1\n         }\n      },\n      {\n         \"data\": {\n            \"Printer Ink\": 142,\n            \"Wireless Speakers\": 60,\n            \"Point & Shoot Cameras\": 48,\n            ...\n         },\n         \"name\": \"category\",\n         \"exhaustive\": false\n      },\n      {\n         \"exhaustive\": false,\n         \"data\": {\n            \"> 5000\": 2,\n            \"1 - 50\": 6524,\n            \"501 - 2000\": 566,\n            \"201 - 500\": 1501,\n            \"101 - 200\": 1360,\n            \"2001 - 5000\": 47\n         },\n         \"name\": \"salePrice_range\"\n      },\n      {\n         \"data\": {\n            \"Dynex™\": 202,\n            \"Insignia™\": 230,\n            \"PNY\": 72,\n            ...\n         },\n         \"name\": \"manufacturer\",\n         \"exhaustive\": false\n      }\n  ],\n   \"query\": \"\",\n   \"nbPages\": 100,\n   \"page\": 0,\n   \"index\": \"bestbuy\"\n}\n **/\n\n/*eslint-enable */\n\n\nfunction SearchResults(state, results) {\n  var mainSubResponse = results[0];\n  this._rawResults = results;\n  var self = this; // https://www.algolia.com/doc/api-reference/api-methods/search/#response\n\n  Object.keys(mainSubResponse).forEach(function (key) {\n    self[key] = mainSubResponse[key];\n  });\n  /**\n   * query used to generate the results\n   * @name query\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * The query as parsed by the engine given all the rules.\n   * @name parsedQuery\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * all the records that match the search parameters. Each record is\n   * augmented with a new attribute `_highlightResult`\n   * which is an object keyed by attribute and with the following properties:\n   *  - `value` : the value of the facet highlighted (html)\n   *  - `matchLevel`: full, partial or none depending on how the query terms match\n   * @name hits\n   * @member {object[]}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * index where the results come from\n   * @name index\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * number of hits per page requested\n   * @name hitsPerPage\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * total number of hits of this query on the index\n   * @name nbHits\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * total number of pages with respect to the number of hits per page and the total number of hits\n   * @name nbPages\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * current page\n   * @name page\n   * @member {number}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * The position if the position was guessed by IP.\n   * @name aroundLatLng\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"48.8637,2.3615\",\n   */\n\n  /**\n   * The radius computed by Algolia.\n   * @name automaticRadius\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"126792922\",\n   */\n\n  /**\n   * String identifying the server used to serve this request.\n   *\n   * getRankingInfo needs to be set to `true` for this to be returned\n   *\n   * @name serverUsed\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   * @example \"c7-use-2.algolia.net\",\n   */\n\n  /**\n   * Boolean that indicates if the computation of the counts did time out.\n   * @deprecated\n   * @name timeoutCounts\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * Boolean that indicates if the computation of the hits did time out.\n   * @deprecated\n   * @name timeoutHits\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * True if the counts of the facets is exhaustive\n   * @name exhaustiveFacetsCount\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * True if the number of hits is exhaustive\n   * @name exhaustiveNbHits\n   * @member {boolean}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * Contains the userData if they are set by a [query rule](https://www.algolia.com/doc/guides/query-rules/query-rules-overview/).\n   * @name userData\n   * @member {object[]}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * queryID is the unique identifier of the query used to generate the current search results.\n   * This value is only available if the `clickAnalytics` search parameter is set to `true`.\n   * @name queryID\n   * @member {string}\n   * @memberof SearchResults\n   * @instance\n   */\n\n  /**\n   * sum of the processing time of all the queries\n   * @member {number}\n   */\n\n  this.processingTimeMS = results.reduce(function (sum, result) {\n    return result.processingTimeMS === undefined ? sum : sum + result.processingTimeMS;\n  }, 0);\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.Facet[]}\n   */\n\n  this.disjunctiveFacets = [];\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.HierarchicalFacet[]}\n   */\n\n  this.hierarchicalFacets = state.hierarchicalFacets.map(function initFutureTree() {\n    return [];\n  });\n  /**\n   * other facets results\n   * @member {SearchResults.Facet[]}\n   */\n\n  this.facets = [];\n  var disjunctiveFacets = state.getRefinedDisjunctiveFacets();\n  var facetsIndices = getIndices(state.facets);\n  var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);\n  var nextDisjunctiveResult = 1; // Since we send request only for disjunctive facets that have been refined,\n  // we get the facets information from the first, general, response.\n\n  var mainFacets = mainSubResponse.facets || {};\n  Object.keys(mainFacets).forEach(function (facetKey) {\n    var facetValueObject = mainFacets[facetKey];\n    var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(state.hierarchicalFacets, facetKey);\n\n    if (hierarchicalFacet) {\n      // Place the hierarchicalFacet data at the correct index depending on\n      // the attributes order that was defined at the helper initialization\n      var facetIndex = hierarchicalFacet.attributes.indexOf(facetKey);\n      var idxAttributeName = findIndex(state.hierarchicalFacets, function (f) {\n        return f.name === hierarchicalFacet.name;\n      });\n      self.hierarchicalFacets[idxAttributeName][facetIndex] = {\n        attribute: facetKey,\n        data: facetValueObject,\n        exhaustive: mainSubResponse.exhaustiveFacetsCount\n      };\n    } else {\n      var isFacetDisjunctive = state.disjunctiveFacets.indexOf(facetKey) !== -1;\n      var isFacetConjunctive = state.facets.indexOf(facetKey) !== -1;\n      var position;\n\n      if (isFacetDisjunctive) {\n        position = disjunctiveFacetsIndices[facetKey];\n        self.disjunctiveFacets[position] = {\n          name: facetKey,\n          data: facetValueObject,\n          exhaustive: mainSubResponse.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.disjunctiveFacets[position], mainSubResponse.facets_stats, facetKey);\n      }\n\n      if (isFacetConjunctive) {\n        position = facetsIndices[facetKey];\n        self.facets[position] = {\n          name: facetKey,\n          data: facetValueObject,\n          exhaustive: mainSubResponse.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.facets[position], mainSubResponse.facets_stats, facetKey);\n      }\n    }\n  }); // Make sure we do not keep holes within the hierarchical facets\n\n  this.hierarchicalFacets = compact(this.hierarchicalFacets); // aggregate the refined disjunctive facets\n\n  disjunctiveFacets.forEach(function (disjunctiveFacet) {\n    var result = results[nextDisjunctiveResult];\n    var facets = result && result.facets ? result.facets : {};\n    var hierarchicalFacet = state.getHierarchicalFacetByName(disjunctiveFacet); // There should be only item in facets.\n\n    Object.keys(facets).forEach(function (dfacet) {\n      var facetResults = facets[dfacet];\n      var position;\n\n      if (hierarchicalFacet) {\n        position = findIndex(state.hierarchicalFacets, function (f) {\n          return f.name === hierarchicalFacet.name;\n        });\n        var attributeIndex = findIndex(self.hierarchicalFacets[position], function (f) {\n          return f.attribute === dfacet;\n        }); // previous refinements and no results so not able to find it\n\n        if (attributeIndex === -1) {\n          return;\n        }\n\n        self.hierarchicalFacets[position][attributeIndex].data = merge({}, self.hierarchicalFacets[position][attributeIndex].data, facetResults);\n      } else {\n        position = disjunctiveFacetsIndices[dfacet];\n        var dataFromMainRequest = mainSubResponse.facets && mainSubResponse.facets[dfacet] || {};\n        self.disjunctiveFacets[position] = {\n          name: dfacet,\n          data: defaultsPure({}, facetResults, dataFromMainRequest),\n          exhaustive: result.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.disjunctiveFacets[position], result.facets_stats, dfacet);\n\n        if (state.disjunctiveFacetsRefinements[dfacet]) {\n          state.disjunctiveFacetsRefinements[dfacet].forEach(function (refinementValue) {\n            // add the disjunctive refinements if it is no more retrieved\n            if (!self.disjunctiveFacets[position].data[refinementValue] && state.disjunctiveFacetsRefinements[dfacet].indexOf(refinementValue) > -1) {\n              self.disjunctiveFacets[position].data[refinementValue] = 0;\n            }\n          });\n        }\n      }\n    });\n    nextDisjunctiveResult++;\n  }); // if we have some root level values for hierarchical facets, merge them\n\n  state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {\n    var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n    var currentRefinement = state.getHierarchicalRefinement(refinedFacet); // if we are already at a root refinement (or no refinement at all), there is no\n    // root level values request\n\n    if (currentRefinement.length === 0 || currentRefinement[0].split(separator).length < 2) {\n      return;\n    }\n\n    var result = results[nextDisjunctiveResult];\n    var facets = result && result.facets ? result.facets : {};\n    Object.keys(facets).forEach(function (dfacet) {\n      var facetResults = facets[dfacet];\n      var position = findIndex(state.hierarchicalFacets, function (f) {\n        return f.name === hierarchicalFacet.name;\n      });\n      var attributeIndex = findIndex(self.hierarchicalFacets[position], function (f) {\n        return f.attribute === dfacet;\n      }); // previous refinements and no results so not able to find it\n\n      if (attributeIndex === -1) {\n        return;\n      } // when we always get root levels, if the hits refinement is `beers > IPA` (count: 5),\n      // then the disjunctive values will be `beers` (count: 100),\n      // but we do not want to display\n      //   | beers (100)\n      //     > IPA (5)\n      // We want\n      //   | beers (5)\n      //     > IPA (5)\n\n\n      var defaultData = {};\n\n      if (currentRefinement.length > 0) {\n        var root = currentRefinement[0].split(separator)[0];\n        defaultData[root] = self.hierarchicalFacets[position][attributeIndex].data[root];\n      }\n\n      self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(defaultData, facetResults, self.hierarchicalFacets[position][attributeIndex].data);\n    });\n    nextDisjunctiveResult++;\n  }); // add the excludes\n\n  Object.keys(state.facetsExcludes).forEach(function (facetName) {\n    var excludes = state.facetsExcludes[facetName];\n    var position = facetsIndices[facetName];\n    self.facets[position] = {\n      name: facetName,\n      data: mainSubResponse.facets[facetName],\n      exhaustive: mainSubResponse.exhaustiveFacetsCount\n    };\n    excludes.forEach(function (facetValue) {\n      self.facets[position] = self.facets[position] || {\n        name: facetName\n      };\n      self.facets[position].data = self.facets[position].data || {};\n      self.facets[position].data[facetValue] = 0;\n    });\n  });\n  /**\n   * @type {Array}\n   */\n\n  this.hierarchicalFacets = this.hierarchicalFacets.map(generateHierarchicalTree(state));\n  /**\n   * @type {Array}\n   */\n\n  this.facets = compact(this.facets);\n  /**\n   * @type {Array}\n   */\n\n  this.disjunctiveFacets = compact(this.disjunctiveFacets);\n  this._state = state;\n}\n/**\n * Get a facet object with its name\n * @deprecated\n * @param {string} name name of the faceted attribute\n * @return {SearchResults.Facet} the facet object\n */\n\n\nSearchResults.prototype.getFacetByName = function (name) {\n  function predicate(facet) {\n    return facet.name === name;\n  }\n\n  return find(this.facets, predicate) || find(this.disjunctiveFacets, predicate) || find(this.hierarchicalFacets, predicate);\n};\n/**\n * Get the facet values of a specified attribute from a SearchResults object.\n * @private\n * @param {SearchResults} results the search results to search in\n * @param {string} attribute name of the faceted attribute to search for\n * @return {array|object} facet values. For the hierarchical facets it is an object.\n */\n\n\nfunction extractNormalizedFacetValues(results, attribute) {\n  function predicate(facet) {\n    return facet.name === attribute;\n  }\n\n  if (results._state.isConjunctiveFacet(attribute)) {\n    var facet = find(results.facets, predicate);\n    if (!facet) return [];\n    return Object.keys(facet.data).map(function (name) {\n      return {\n        name: name,\n        count: facet.data[name],\n        isRefined: results._state.isFacetRefined(attribute, name),\n        isExcluded: results._state.isExcludeRefined(attribute, name)\n      };\n    });\n  } else if (results._state.isDisjunctiveFacet(attribute)) {\n    var disjunctiveFacet = find(results.disjunctiveFacets, predicate);\n    if (!disjunctiveFacet) return [];\n    return Object.keys(disjunctiveFacet.data).map(function (name) {\n      return {\n        name: name,\n        count: disjunctiveFacet.data[name],\n        isRefined: results._state.isDisjunctiveFacetRefined(attribute, name)\n      };\n    });\n  } else if (results._state.isHierarchicalFacet(attribute)) {\n    return find(results.hierarchicalFacets, predicate);\n  }\n}\n/**\n * Sort nodes of a hierarchical facet results\n * @private\n * @param {HierarchicalFacet} node node to upon which we want to apply the sort\n */\n\n\nfunction recSort(sortFn, node) {\n  if (!node.data || node.data.length === 0) {\n    return node;\n  }\n\n  var children = node.data.map(function (childNode) {\n    return recSort(sortFn, childNode);\n  });\n  var sortedChildren = sortFn(children);\n  var newNode = merge({}, node, {\n    data: sortedChildren\n  });\n  return newNode;\n}\n\nSearchResults.DEFAULT_SORT = ['isRefined:desc', 'count:desc', 'name:asc'];\n\nfunction vanillaSortFn(order, data) {\n  return data.sort(order);\n}\n/**\n * Get a the list of values for a given facet attribute. Those values are sorted\n * refinement first, descending count (bigger value on top), and name ascending\n * (alphabetical order). The sort formula can overridden using either string based\n * predicates or a function.\n *\n * This method will return all the values returned by the Algolia engine plus all\n * the values already refined. This means that it can happen that the\n * `maxValuesPerFacet` [configuration](https://www.algolia.com/doc/rest-api/search#param-maxValuesPerFacet)\n * might not be respected if you have facet values that are already refined.\n * @param {string} attribute attribute name\n * @param {object} opts configuration options.\n * @param {Array.<string> | function} opts.sortBy\n * When using strings, it consists of\n * the name of the [FacetValue](#SearchResults.FacetValue) or the\n * [HierarchicalFacet](#SearchResults.HierarchicalFacet) attributes with the\n * order (`asc` or `desc`). For example to order the value by count, the\n * argument would be `['count:asc']`.\n *\n * If only the attribute name is specified, the ordering defaults to the one\n * specified in the default value for this attribute.\n *\n * When not specified, the order is\n * ascending.  This parameter can also be a function which takes two facet\n * values and should return a number, 0 if equal, 1 if the first argument is\n * bigger or -1 otherwise.\n *\n * The default value for this attribute `['isRefined:desc', 'count:desc', 'name:asc']`\n * @return {FacetValue[]|HierarchicalFacet|undefined} depending on the type of facet of\n * the attribute requested (hierarchical, disjunctive or conjunctive)\n * @example\n * helper.on('result', function(event){\n *   //get values ordered only by name ascending using the string predicate\n *   event.results.getFacetValues('city', {sortBy: ['name:asc']});\n *   //get values  ordered only by count ascending using a function\n *   event.results.getFacetValues('city', {\n *     // this is equivalent to ['count:asc']\n *     sortBy: function(a, b) {\n *       if (a.count === b.count) return 0;\n *       if (a.count > b.count)   return 1;\n *       if (b.count > a.count)   return -1;\n *     }\n *   });\n * });\n */\n\n\nSearchResults.prototype.getFacetValues = function (attribute, opts) {\n  var facetValues = extractNormalizedFacetValues(this, attribute);\n\n  if (!facetValues) {\n    return undefined;\n  }\n\n  var options = defaultsPure({}, opts, {\n    sortBy: SearchResults.DEFAULT_SORT\n  });\n\n  if (Array.isArray(options.sortBy)) {\n    var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);\n\n    if (Array.isArray(facetValues)) {\n      return orderBy(facetValues, order[0], order[1]);\n    } // If facetValues is not an array, it's an object thus a hierarchical facet object\n\n\n    return recSort(function (hierarchicalFacetValues) {\n      return orderBy(hierarchicalFacetValues, order[0], order[1]);\n    }, facetValues);\n  } else if (typeof options.sortBy === 'function') {\n    if (Array.isArray(facetValues)) {\n      return facetValues.sort(options.sortBy);\n    } // If facetValues is not an array, it's an object thus a hierarchical facet object\n\n\n    return recSort(function (data) {\n      return vanillaSortFn(options.sortBy, data);\n    }, facetValues);\n  }\n\n  throw new Error('options.sortBy is optional but if defined it must be ' + 'either an array of string (predicates) or a sorting function');\n};\n/**\n * Returns the facet stats if attribute is defined and the facet contains some.\n * Otherwise returns undefined.\n * @param {string} attribute name of the faceted attribute\n * @return {object} The stats of the facet\n */\n\n\nSearchResults.prototype.getFacetStats = function (attribute) {\n  if (this._state.isConjunctiveFacet(attribute)) {\n    return getFacetStatsIfAvailable(this.facets, attribute);\n  } else if (this._state.isDisjunctiveFacet(attribute)) {\n    return getFacetStatsIfAvailable(this.disjunctiveFacets, attribute);\n  }\n\n  return undefined;\n};\n/**\n * @typedef {Object} FacetListItem\n * @property {string} name\n */\n\n/**\n * @param {FacetListItem[]} facetList (has more items, but enough for here)\n * @param {string} facetName\n */\n\n\nfunction getFacetStatsIfAvailable(facetList, facetName) {\n  var data = find(facetList, function (facet) {\n    return facet.name === facetName;\n  });\n  return data && data.stats;\n}\n/**\n * Returns all refinements for all filters + tags. It also provides\n * additional information: count and exhaustiveness for each filter.\n *\n * See the [refinement type](#Refinement) for an exhaustive view of the available\n * data.\n *\n * Note that for a numeric refinement, results are grouped per operator, this\n * means that it will return responses for operators which are empty.\n *\n * @return {Array.<Refinement>} all the refinements\n */\n\n\nSearchResults.prototype.getRefinements = function () {\n  var state = this._state;\n  var results = this;\n  var res = [];\n  Object.keys(state.facetsRefinements).forEach(function (attributeName) {\n    state.facetsRefinements[attributeName].forEach(function (name) {\n      res.push(getRefinement(state, 'facet', attributeName, name, results.facets));\n    });\n  });\n  Object.keys(state.facetsExcludes).forEach(function (attributeName) {\n    state.facetsExcludes[attributeName].forEach(function (name) {\n      res.push(getRefinement(state, 'exclude', attributeName, name, results.facets));\n    });\n  });\n  Object.keys(state.disjunctiveFacetsRefinements).forEach(function (attributeName) {\n    state.disjunctiveFacetsRefinements[attributeName].forEach(function (name) {\n      res.push(getRefinement(state, 'disjunctive', attributeName, name, results.disjunctiveFacets));\n    });\n  });\n  Object.keys(state.hierarchicalFacetsRefinements).forEach(function (attributeName) {\n    state.hierarchicalFacetsRefinements[attributeName].forEach(function (name) {\n      res.push(getHierarchicalRefinement(state, attributeName, name, results.hierarchicalFacets));\n    });\n  });\n  Object.keys(state.numericRefinements).forEach(function (attributeName) {\n    var operators = state.numericRefinements[attributeName];\n    Object.keys(operators).forEach(function (operator) {\n      operators[operator].forEach(function (value) {\n        res.push({\n          type: 'numeric',\n          attributeName: attributeName,\n          name: value,\n          numericValue: value,\n          operator: operator\n        });\n      });\n    });\n  });\n  state.tagRefinements.forEach(function (name) {\n    res.push({\n      type: 'tag',\n      attributeName: '_tags',\n      name: name\n    });\n  });\n  return res;\n};\n/**\n * @typedef {Object} Facet\n * @property {string} name\n * @property {Object} data\n * @property {boolean} exhaustive\n */\n\n/**\n * @param {*} state\n * @param {*} type\n * @param {string} attributeName\n * @param {*} name\n * @param {Facet[]} resultsFacets\n */\n\n\nfunction getRefinement(state, type, attributeName, name, resultsFacets) {\n  var facet = find(resultsFacets, function (f) {\n    return f.name === attributeName;\n  });\n  var count = facet && facet.data && facet.data[name] ? facet.data[name] : 0;\n  var exhaustive = facet && facet.exhaustive || false;\n  return {\n    type: type,\n    attributeName: attributeName,\n    name: name,\n    count: count,\n    exhaustive: exhaustive\n  };\n}\n/**\n * @param {*} state\n * @param {string} attributeName\n * @param {*} name\n * @param {Facet[]} resultsFacets\n */\n\n\nfunction getHierarchicalRefinement(state, attributeName, name, resultsFacets) {\n  var facetDeclaration = state.getHierarchicalFacetByName(attributeName);\n\n  var separator = state._getHierarchicalFacetSeparator(facetDeclaration);\n\n  var split = name.split(separator);\n  var rootFacet = find(resultsFacets, function (facet) {\n    return facet.name === attributeName;\n  });\n  var facet = split.reduce(function (intermediateFacet, part) {\n    var newFacet = intermediateFacet && find(intermediateFacet.data, function (f) {\n      return f.name === part;\n    });\n    return newFacet !== undefined ? newFacet : intermediateFacet;\n  }, rootFacet);\n  var count = facet && facet.count || 0;\n  var exhaustive = facet && facet.exhaustive || false;\n  var path = facet && facet.path || '';\n  return {\n    type: 'hierarchical',\n    attributeName: attributeName,\n    name: path,\n    count: count,\n    exhaustive: exhaustive\n  };\n}\n\nmodule.exports = SearchResults;","/**\r\n * SEO component that queries for data with\r\n *  Gatsby's useStaticQuery React hook\r\n *\r\n * See: https://www.gatsbyjs.com/docs/use-static-query/\r\n */\r\n\r\nimport React from \"react\"\r\nimport PropTypes from \"prop-types\"\r\nimport { Helmet } from \"react-helmet\"\r\nimport { useStaticQuery, graphql } from \"gatsby\"\r\n\r\nfunction SEO({ description, lang, meta, title }) {\r\n  const { site } = useStaticQuery(\r\n    graphql`\r\n      query {\r\n        site {\r\n          siteMetadata {\r\n            title\r\n            description\r\n            author\r\n          }\r\n        }\r\n      }\r\n    `\r\n  )\r\n\r\n  const metaDescription = description || site.siteMetadata.description\r\n  const defaultTitle = site.siteMetadata?.title\r\n\r\n  return (\r\n    <Helmet\r\n      htmlAttributes={{\r\n        lang,\r\n      }}\r\n      title={title}\r\n      titleTemplate={defaultTitle ? `%s | ${defaultTitle}` : null}\r\n      meta={[\r\n        {\r\n          name: `description`,\r\n          content: metaDescription,\r\n        },\r\n        {\r\n          property: `og:title`,\r\n          content: title,\r\n        },\r\n        {\r\n          property: `og:description`,\r\n          content: metaDescription,\r\n        },\r\n        {\r\n          property: `og:type`,\r\n          content: `website`,\r\n        },\r\n        {\r\n          name: `twitter:card`,\r\n          content: `summary`,\r\n        },\r\n        {\r\n          name: `twitter:creator`,\r\n          content: site.siteMetadata?.author || ``,\r\n        },\r\n        {\r\n          name: `twitter:title`,\r\n          content: title,\r\n        },\r\n        {\r\n          name: `twitter:description`,\r\n          content: metaDescription,\r\n        },\r\n      ].concat(meta)}\r\n    />\r\n  )\r\n}\r\n\r\nSEO.defaultProps = {\r\n  lang: `en`,\r\n  meta: [],\r\n  description: ``,\r\n}\r\n\r\nSEO.propTypes = {\r\n  description: PropTypes.string,\r\n  lang: PropTypes.string,\r\n  meta: PropTypes.arrayOf(PropTypes.object),\r\n  title: PropTypes.string.isRequired,\r\n}\r\n\r\nexport default SEO\r\n","'use strict';\n\nfunction compareAscending(value, other) {\n  if (value !== other) {\n    var valIsDefined = value !== undefined;\n    var valIsNull = value === null;\n    var othIsDefined = other !== undefined;\n    var othIsNull = other === null;\n\n    if (!othIsNull && value > other || valIsNull && othIsDefined || !valIsDefined) {\n      return 1;\n    }\n\n    if (!valIsNull && value < other || othIsNull && valIsDefined || !othIsDefined) {\n      return -1;\n    }\n  }\n\n  return 0;\n}\n/**\n * @param {Array<object>} collection object with keys in attributes\n * @param {Array<string>} iteratees attributes\n * @param {Array<string>} orders asc | desc\n */\n\n\nfunction orderBy(collection, iteratees, orders) {\n  if (!Array.isArray(collection)) {\n    return [];\n  }\n\n  if (!Array.isArray(orders)) {\n    orders = [];\n  }\n\n  var result = collection.map(function (value, index) {\n    return {\n      criteria: iteratees.map(function (iteratee) {\n        return value[iteratee];\n      }),\n      index: index,\n      value: value\n    };\n  });\n  result.sort(function comparer(object, other) {\n    var index = -1;\n\n    while (++index < object.criteria.length) {\n      var res = compareAscending(object.criteria[index], other.criteria[index]);\n\n      if (res) {\n        if (index >= orders.length) {\n          return res;\n        }\n\n        if (orders[index] === 'desc') {\n          return -res;\n        }\n\n        return res;\n      }\n    } // This ensures a stable sort in V8 and other engines.\n    // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n\n\n    return object.index - other.index;\n  });\n  return result.map(function (res) {\n    return res.value;\n  });\n}\n\nmodule.exports = orderBy;","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n"],"sourceRoot":""}