{"version":3,"sources":["webpack:///./node_modules/algoliasearch-helper/src/functions/formatSort.js","webpack:///./node_modules/algoliasearch/src/version.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/shortener.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/RefinementList.js","webpack:///./node_modules/algoliasearch/src/deprecatedMessage.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/filterState.js","webpack:///./node_modules/algoliasearch-helper/src/DerivedHelper/index.js","webpack:///./node_modules/algoliasearch/src/merge.js","webpack:///./node_modules/algoliasearch/src/omit.js","webpack:///./node_modules/algoliasearch/src/browser/createAlgoliasearch.js","webpack:///./node_modules/algoliasearch-helper/index.js","webpack:///./node_modules/algoliasearch-helper/src/SearchParameters/index.js","webpack:///./node_modules/algoliasearch/src/errors.js","webpack:///./node_modules/algoliasearch/src/browser/inline-headers.js","webpack:///./node_modules/algoliasearch/src/exitPromise.js","webpack:///./node_modules/algoliasearch/node_modules/debug/src/debug.js","webpack:///./node_modules/algoliasearch/src/store.js","webpack:///./node_modules/algoliasearch/src/IndexCore.js","webpack:///./node_modules/algoliasearch-helper/src/url.js","webpack:///./node_modules/algoliasearch-helper/src/SearchResults/generate-hierarchical-tree.js","webpack:///./node_modules/algoliasearch/src/deprecate.js","webpack:///./node_modules/algoliasearch-helper/src/functions/valToNumber.js","webpack:///./node_modules/algoliasearch/src/clone.js","webpack:///./node_modules/algoliasearch-helper/src/SearchResults/index.js","webpack:///./node_modules/algoliasearch/src/browser/builds/algoliasearchLite.js","webpack:///./node_modules/algoliasearch/src/AlgoliaSearchCore.js","webpack:///./node_modules/algoliasearch-helper/src/requestBuilder.js","webpack:///./node_modules/algoliasearch/src/places.js","webpack:///./node_modules/algoliasearch-helper/src/version.js","webpack:///./node_modules/algoliasearch-helper/src/algoliasearch.helper.js","webpack:///./node_modules/algoliasearch/src/map.js","webpack:///./node_modules/algoliasearch/node_modules/debug/src/browser.js","webpack:///./node_modules/algoliasearch/src/buildSearchMethod.js","webpack:///./node_modules/algoliasearch/src/browser/jsonp-request.js"],"names":["reduce","find","startsWith","module","exports","sortBy","defaults","out","sortInstruction","sortInstructions","split","length","similarDefault","predicate","push","invert","keys","keys2Short","advancedSyntax","allowTyposOnNumericTokens","analyticsTags","analytics","aroundLatLngViaIP","aroundLatLng","aroundPrecision","aroundRadius","attributesToHighlight","attributesToRetrieve","attributesToSnippet","disjunctiveFacetsRefinements","disjunctiveFacets","distinct","facetsExcludes","facetsRefinements","facets","getRankingInfo","hierarchicalFacetsRefinements","hierarchicalFacets","highlightPostTag","highlightPreTag","hitsPerPage","ignorePlurals","index","insideBoundingBox","insidePolygon","maxValuesPerFacet","minimumAroundRadius","minProximity","minWordSizefor1Typo","minWordSizefor2Typos","numericFilters","numericRefinements","offset","optionalWords","page","queryType","query","removeWordsIfNoResults","replaceSynonymsInHighlight","restrictSearchableAttributes","synonyms","tagFilters","tagRefinements","typoTolerance","optionalTagFilters","optionalFacetFilters","snippetEllipsisText","disableExactOnAttributes","enableExactOnSingleWordQuery","short2Keys","ENCODED_PARAMETERS","decode","shortKey","encode","key","isUndefined","isString","isFunction","isEmpty","filter","omit","lib","addRefinement","refinementList","attribute","value","isRefined","valueAsString","facetRefinement","concat","mod","removeRefinement","clearRefinement","v","f","toggleRefinement","Error","refinementType","hasChanged","newRefinementList","memo","values","facetList","refinementValue","indexOf","containsRefinements","refinementValueAsString","previousUsage","newUsage","githubAnchorLink","toLowerCase","replace","forEach","map","filterState","state","filters","partialState","attributeFilters","attributes","aF","attr","isConjunctiveFacet","isFacetRefined","isDisjunctiveFacet","isDisjunctiveFacetRefined","isHierarchicalFacet","isHierarchicalFacetRefined","getNumericRefinements","searchParameters","parameterKey","util","events","DerivedHelper","mainHelper","fn","this","main","lastResults","inherits","EventEmitter","prototype","detach","removeAllListeners","detachDerivedHelper","getModifiedState","parameters","foreach","merge","destination","sources","Array","slice","call","arguments","source","keyName","hasOwnProperty","undefined","obj","test","filtered","global","Promise","AlgoliaSearch","uaSuffix","errors","inlineHeaders","jsonpRequest","places","algoliasearch","applicationID","apiKey","opts","cloneDeep","_ua","ua","AlgoliaSearchBrowser","version","initPlaces","__algolia","debug","support","hasXMLHttpRequest","hasXDomainRequest","apply","cors","XMLHttpRequest","_request","url","resolve","reject","headers","reqTimeout","timedOut","body","req","XDomainRequest","connected","setTimeout","onTimeout","timeouts","connect","onprogress","onProgress","onreadystatechange","onReadyStateChange","onload","onLoad","onerror","onError","open","method","forceAuthHeaders","setRequestHeader","send","Network","clearTimeout","JSON","parse","responseText","statusCode","status","getAllResponseHeaders","e","UnparsableJSON","more","event","abort","RequestTimeout","onConnect","complete","readyState","fallback","err","content","_promise","val","delay","ms","all","promises","AlgoliaSearchHelper","SearchParameters","SearchResults","algoliasearchHelper","client","intersection","forOwn","isNaN","isEqual","trim","valToNumber","RefinementList","findArray","array","searchedValue","currentValue","newParameters","params","_parseNumbers","self","paramValue","paramName","PARAMETERS","numbers","numberKeys","k","parsedValue","parseFloat","isArray","geoRect","operators","operator","parsedValues","vPrime","make","instance","facet","rootPath","currentRefinement","getHierarchicalRefinement","name","clearRefinements","toggleHierarchicalFacetRefinement","validate","currentState","constructor","clear","patch","_clearNumericRefinements","setQueryParameters","clearTags","setIndex","setQuery","newQuery","setPage","newPage","setFacets","setDisjunctiveFacets","setHitsPerPage","n","setTypoTolerance","addNumericRefinement","isNumericRefined","getConjunctiveRefinements","facetName","getDisjunctiveRefinements","getExcludeRefinements","removeNumericRefinement","paramValueAsNumber","op","getNumericRefinement","newNumericRefinements","operatorList","outValues","predicateResult","addFacet","addDisjunctiveFacet","addHierarchicalFacet","hierarchicalFacet","addFacetRefinement","addExcludeRefinement","addDisjunctiveFacetRefinement","addTagRefinement","tag","isTagRefined","modification","removeFacet","removeDisjunctiveFacet","removeHierarchicalFacet","removeFacetRefinement","removeExcludeRefinement","removeDisjunctiveFacetRefinement","removeTagRefinement","t","toggleFacetRefinement","toggleConjunctiveFacetRefinement","toggleDisjunctiveFacetRefinement","toggleExcludeFacetRefinement","separator","_getHierarchicalFacetSeparator","getHierarchicalFacetByName","upOneOrMultipleLevel","lastIndexOf","addHierarchicalFacetRefinement","path","removeHierarchicalFacetRefinement","toggleTagRefinement","isExcludeRefined","refinements","isOperatorDefined","isAttributeValueDefined","getRefinedDisjunctiveFacets","disjunctiveNumericRefinedFacets","getRefinedHierarchicalFacets","getUnrefinedDisjunctiveFacets","refinedFacets","managedParameters","getQueryParams","queryParams","getQueryParameter","setQueryParameter","parameter","error","parsedParams","mutateMe","newInstance","ks","newState","_getHierarchicalFacetSortBy","_getHierarchicalRootPath","_getHierarchicalShowParentLevel","showParentLevel","hierarchicalFacetName","getHierarchicalFacetBreadcrumb","refinement","toString","stringify","AlgoliaSearchError","message","extraProperties","captureStackTrace","stack","createCustomError","AlgoliaSearchCustomError","args","unshift","JSONPScriptFail","JSONPScriptError","Unknown","_setTimeout","prevTime","selectColor","namespace","i","hash","charCodeAt","colors","Math","abs","createDebug","enabled","curr","Date","diff","prev","coerce","match","format","formatter","formatters","splice","formatArgs","logFn","log","console","bind","useColors","color","init","enable","namespaces","save","names","skips","len","RegExp","substr","disable","humanize","store","localStorageNamespace","moduleStore","set","data","get","localStorageStore","localStorage","localStorageFailure","cleanup","getOrSet","supportsLocalStorage","setItem","_","removeItem","buildSearchMethod","deprecate","deprecatedMessage","IndexCore","indexName","as","typeAheadArgs","typeAheadValueOption","cache","clearCache","search","similarSearch","browse","queryParameters","callback","indexObj","_getSearchParams","_jsonRequest","encodeURIComponent","hostType","browseFrom","cursor","searchForFacetValues","clone","usage","facetQuery","filteredParams","searchFacet","_search","additionalUA","getObject","objectID","attrs","getObjects","objectIDs","requests","request","join","shortener","qs","pick","mapKeys","mapValues","isPlainObject","recursiveEncode","input","refinementsParameters","stateKeys","sortQueryStringValues","prefixRegexp","invertedMapping","a","b","isARefinements","isBRefinements","localeCompare","getStateFromQueryString","queryString","options","prefixForParameters","prefix","mapping","partialStateWithPrefix","hasPrefix","unprefixedKey","decodedKey","partialStateWithParsedNumbers","getUnrecognizedParametersInQueryString","foreignConfig","config","getQueryStringFromState","moreAttributes","safe","stateForUrl","encodedState","shortK","sort","stateQs","moreQs","generateTrees","last","orderBy","pickBy","prepareHierarchicalFacetSortBy","hierarchicalFacetResult","hierarchicalFacetIndex","hierarchicalFacetRefinement","hierarchicalSeparator","hierarchicalRootPath","hierarchicalShowParentLevel","generateTreeFn","generateHierarchicalTree","results","count","hierarchicalTree","currentHierarchicalLevel","parent","level","onlyMatchingValuesFn","filterFacetValues","formatHierarchicalFacetValue","parentPath","facetCount","facetValue","warned","deprecated","warn","isNumber","compact","findIndex","sumBy","includes","partial","partialRight","formatSort","getIndices","indices","idx","assignFacetStats","dest","facetStats","stats","findMatchingHierarchicalFacetFromAttributeName","hierarchicalAttributeName","mainSubResponse","_rawResults","parsedQuery","hits","nbHits","nbPages","processingTimeMS","automaticRadius","serverUsed","timeoutCounts","timeoutHits","exhaustiveFacetsCount","exhaustiveNbHits","userData","queryID","facetsIndices","disjunctiveFacetsIndices","nextDisjunctiveResult","facetValueObject","facetKey","facetIndex","idxAttributeName","exhaustive","position","isFacetDisjunctive","isFacetConjunctive","facets_stats","disjunctiveFacet","result","facetResults","dfacet","attributeIndex","dataFromMainRequest","refinedFacet","defaultData","root","excludes","_state","extractNormalizedFacetValues","isExcluded","recSort","sortFn","node","children","sortedChildren","newNode","vanillaSortFn","order","getFacetStatsIfAvailable","getRefinement","type","attributeName","resultsFacets","facetDeclaration","splitted","configuredName","getFacetByName","DEFAULT_SORT","getFacetValues","facetValues","getFacetStats","getRefinements","res","numericValue","AlgoliaSearchCore","createAlgoliasearch","exitPromise","MAX_API_KEY_LENGTH","RESET_APP_DATA_TIMER","parseInt","_allowEmptyCredentials","hosts","read","write","_timeouts","timeout","protocol","_checkAppIdData","defaultHosts","_shuffleResult","hostNumber","mainSuffix","dsn","prepareHost","extraHeaders","_cache","_useCache","_useRequestCache","_useFallback","useFallback","host","safeJSONStringify","toJSON","shuffle","temporaryValue","randomIndex","currentIndex","floor","random","removeCredentials","newHeaders","headerName","Object","initIndex","setExtraHeader","getExtraHeader","unsetExtraHeader","addAlgoliaAgent","algoliaAgent","initialOpts","cacheID","requestDebug","tries","usingFallback","hasFallback","_computeRequestHeaders","withApiKey","debugData","doRequest","requester","reqOpts","startTime","isCacheValidWithCurrentID","jsonBody","_getTimeoutsForRequest","_setHostIndexByType","currentHost","_getHostByType","then","success","tryFallback","httpResponse","httpResponseOk","endTime","contentLength","duration","shouldRetry","retryRequest","unrecoverableError","retryRequestWithHigherTimeout","_incrementHostIndex","_incrementTimeoutMultipler","useRequestCache","currentCache","currentCacheID","interopCallbackReturn","catch","maybePromiseForCache","promiseForCache","requestHeaders","userToken","securityTags","queries","postObj","JSONPParams","requestId","strategy","setSecurityTags","tags","strTags","oredTags","j","setUserToken","setRequestTimeout","milliseconds","setTimeouts","getTimeouts","_getAppIdData","_cacheAppIdData","_setAppIdData","lastChange","getTime","now","_resetInitialAppIdData","newData","hostIndexes","timeoutMultiplier","shuffleResult","_hostIndexes","_timeoutMultiplier","_partialAppIdDataUpdate","currentData","_getHostIndexByType","_getTimeoutMultiplier","hostIndex","newHostIndexes","max","requestBuilder","_getQueries","_getHitsSearchParams","_getDisjunctiveFacetSearchParams","_getHitsHierarchicalFacetsAttributes","facetFilters","_getFacetFilters","_getNumericFilters","_getTagFilters","additionalParams","hierarchicalRootLevel","clickAnalytics","_getDisjunctiveHierarchicalFacetAttribute","vs","orFilters","attributeToRefine","attributesIndex","allAttributes","hierarchicalRefinement","newAttributes","rootLevel","parentLevel","getSearchForFacetQuery","maxFacetHits","stateForSearchForFacetValues","searchForFacetSearchParameters","createPlacesClient","qs3","appID","reverse","encoded","flatten","doesClientAgentContainsHelper","setClient","_queryId","_lastQueryIdReceived","derivedHelpers","_currentNbQueries","setCurrentPage","_change","getCurrentPage","currentAgent","getQuery","searchOnce","cb","tempState","emit","_originalResponse","userState","isDisjunctive","algoliaQuery","searchForFacetValuesPromise","facetHits","q","addDisjunctiveRefine","addRefine","addFacetExclusion","addExclude","addTag","removeDisjunctiveRefine","removeRefine","removeFacetExclusion","removeExclude","removeTag","toggleFacetExclusion","toggleExclude","toggleRefine","toggleTag","nextPage","previousPage","setState","getState","getStateAsQueryString","getConfigurationFromQueryString","getForeignConfigurationInQueryString","setStateFromQueryString","triggerChange","configuration","updatedState","overrideStateWithoutTriggeringChangeEvent","hasRefinements","isDisjunctiveRefined","hasTag","hasTagRefinements","getIndex","getPage","getTags","parameterName","conjRefinements","r","excludeRefinements","disjRefinements","mainQueries","states","queriesCount","helper","derivedQueries","derivedHelper","derivedState","queryId","_dispatchAlgoliaResponse","_dispatchAlgoliaError","s","specificResults","formattedResponse","containsRefinement","_hasDisjunctiveRefinements","disjunctiveRefinements","newClient","getClient","derive","pos","hasPendingRequests","arr","newArr","item","itemIndex","window","process","document","documentElement","style","WebkitAppearance","firebug","exception","table","navigator","userAgent","$1","c","lastC","Function","storage","load","DEBUG","localstorage","chrome","local","queryParam","JSONPCounter","cbCalled","head","getElementsByTagName","script","createElement","cbName","done","removeGlobals","clean","ontimeout","readystatechange","async","defer","src","appendChild","removeChild"],"mappings":"0HAEA,IAAIA,EAAS,EAAQ,QACjBC,EAAO,EAAQ,QACfC,EAAa,EAAQ,QAOzBC,EAAOC,QAAU,SAAoBC,EAAQC,GAC3C,OAAON,EAAOK,GAAQ,SAA0BE,EAAKC,GACnD,IAAIC,EAAmBD,EAAgBE,MAAM,KAC7C,GAAIJ,GAAwC,IAA5BG,EAAiBE,OAAc,CAC7C,IAAIC,EAAiBX,EAAKK,GAAU,SAASO,GAC3C,OAAOX,EAAWW,EAAWL,EAAgB,OAE3CI,IACFH,EAAmBG,EAAeF,MAAM,MAK5C,OAFAH,EAAI,GAAGO,KAAKL,EAAiB,IAC7BF,EAAI,GAAGO,KAAKL,EAAiB,IACtBF,IACN,CAAC,GAAI,O,oCCvBVJ,EAAOC,QAAU,U,oCCAjB,IAAIW,EAAS,EAAQ,QACjBC,EAAO,EAAQ,QAEfC,EAAa,CACfC,eAAgB,KAChBC,0BAA2B,QAC3BC,cAAe,KACfC,UAAW,IACXC,kBAAmB,SACnBC,aAAc,MACdC,gBAAiB,KACjBC,aAAc,KACdC,sBAAuB,MACvBC,qBAAsB,MACtBC,oBAAqB,MACrBC,6BAA8B,MAC9BC,kBAAmB,KACnBC,SAAU,IACVC,eAAgB,KAChBC,kBAAmB,KACnBC,OAAQ,IACRC,eAAgB,MAChBC,8BAA+B,MAC/BC,mBAAoB,KACpBC,iBAAkB,OAClBC,gBAAiB,OACjBC,YAAa,MACbC,cAAe,KACfC,MAAO,MACPC,kBAAmB,MACnBC,cAAe,MACfjC,OAAQ,IACRkC,kBAAmB,OACnBC,oBAAqB,MACrBC,aAAc,KACdC,oBAAqB,QACrBC,qBAAsB,QACtBC,eAAgB,KAChBC,mBAAoB,KACpBC,OAAQ,IACRC,cAAe,KACfC,KAAM,IACNC,UAAW,KACXC,MAAO,IACPC,uBAAwB,QACxBC,2BAA4B,OAC5BC,6BAA8B,MAC9BC,SAAU,IACVC,WAAY,KACZC,eAAgB,KAChBC,cAAe,KACfC,mBAAoB,MACpBC,qBAAsB,MACtBC,oBAAqB,MACrBC,yBAA0B,OAC1BC,6BAA8B,UAG5BC,EAAatD,EAAOE,GAExBd,EAAOC,QAAU,CAKfkE,mBAAoBtD,EAAKqD,GAMzBE,OAAQ,SAASC,GACf,OAAOH,EAAWG,IAOpBC,OAAQ,SAASC,GACf,OAAOzD,EAAWyD,M,oCCpEtB,IAAIC,EAAc,EAAQ,QACtBC,EAAW,EAAQ,QACnBC,EAAa,EAAQ,QACrBC,EAAU,EAAQ,QAClBxE,EAAW,EAAQ,QAEnBN,EAAS,EAAQ,QACjB+E,EAAS,EAAQ,QACjBC,EAAO,EAAQ,QAEfC,EAAM,CAQRC,cAAe,SAAuBC,EAAgBC,EAAWC,GAC/D,GAAIJ,EAAIK,UAAUH,EAAgBC,EAAWC,GAC3C,OAAOF,EAGT,IAAII,EAAgB,GAAKF,EAErBG,EAAmBL,EAAeC,GAEpCD,EAAeC,GAAWK,OAAOF,GADjC,CAACA,GAGCG,EAAM,GAIV,OAFAA,EAAIN,GAAaI,EAEVlF,EAAS,GAAIoF,EAAKP,IAW3BQ,iBAAkB,SAA0BR,EAAgBC,EAAWC,GACrE,GAAIV,EAAYU,GACd,OAAOJ,EAAIW,gBAAgBT,EAAgBC,GAG7C,IAAIG,EAAgB,GAAKF,EAEzB,OAAOJ,EAAIW,gBAAgBT,GAAgB,SAASU,EAAGC,GACrD,OAAOV,IAAcU,GAAKP,IAAkBM,MAUhDE,iBAAkB,SAA0BZ,EAAgBC,EAAWC,GACrE,GAAIV,EAAYU,GAAQ,MAAM,IAAIW,MAAM,gDAExC,OAAIf,EAAIK,UAAUH,EAAgBC,EAAWC,GACpCJ,EAAIU,iBAAiBR,EAAgBC,EAAWC,GAGlDJ,EAAIC,cAAcC,EAAgBC,EAAWC,IAatDO,gBAAiB,SAAyBT,EAAgBC,EAAWa,GACnE,GAAItB,EAAYS,GACd,OAAIN,EAAQK,GAAwBA,EAC7B,GACF,GAAIP,EAASQ,GAClB,OAAIN,EAAQK,EAAeC,IAAoBD,EACxCH,EAAKG,EAAgBC,GACvB,GAAIP,EAAWO,GAAY,CAChC,IAAIc,GAAa,EAEbC,EAAoBnG,EAAOmF,GAAgB,SAASiB,EAAMC,EAAQ3B,GACpE,IAAI4B,EAAYvB,EAAOsB,GAAQ,SAAShB,GACtC,OAAQD,EAAUC,EAAOX,EAAKuB,MAShC,OANKnB,EAAQwB,GAIRJ,GAAa,GAHZI,EAAU3F,SAAW0F,EAAO1F,SAAQuF,GAAa,GACrDE,EAAK1B,GAAO4B,GAIPF,IACN,IAEH,OAAIF,EAAmBC,EAChBhB,IAYXG,UAAW,SAAmBH,EAAgBC,EAAWmB,GACvD,IAAIC,EAAU,EAAQ,QAElBC,IAAwBtB,EAAeC,IACzCD,EAAeC,GAAWzE,OAAS,EAErC,GAAIgE,EAAY4B,KAAqBE,EACnC,OAAOA,EAGT,IAAIC,EAA0B,GAAKH,EAEnC,OAAwE,IAAjEC,EAAQrB,EAAeC,GAAYsB,KAI9CvG,EAAOC,QAAU6E,G,mBCrJjB9E,EAAOC,QAAU,SAA2BuG,EAAeC,GACzD,IAAIC,EAAmBF,EAAcG,cAClCC,QAAQ,YAAa,IAExB,MAAO,mBAAqBJ,EAAgB,sBAAwBC,EAClE,4FAA8FC,I,oCCHlG,IAAIG,EAAU,EAAQ,QAClBjC,EAAS,EAAQ,QACjBkC,EAAM,EAAQ,QACdnC,EAAU,EAAQ,QAClB0B,EAAU,EAAQ,QAEtB,SAASU,EAAYC,EAAOC,GAC1B,IAAIC,EAAe,GACfC,EAAmBvC,EAAOqC,GAAS,SAAStB,GAAK,OAAoC,IAA7BA,EAAEU,QAAQ,iBAClEe,EAAaN,EAAIK,GAAkB,SAASE,GAAM,OAAOA,EAAG9G,MAAM,KAAK,OAEzC,IAA9B8F,EAAQe,EAAY,KACtBP,EAAQO,GAAY,SAASE,GACvBN,EAAMO,mBAAmBD,IAASN,EAAMQ,eAAeF,KACpDJ,EAAapF,oBAAmBoF,EAAapF,kBAAoB,IACtEoF,EAAapF,kBAAkBwF,GAAQN,EAAMlF,kBAAkBwF,IAG7DN,EAAMS,mBAAmBH,IAASN,EAAMU,0BAA0BJ,KAC/DJ,EAAaxF,+BAA8BwF,EAAaxF,6BAA+B,IAC5FwF,EAAaxF,6BAA6B4F,GAAQN,EAAMtF,6BAA6B4F,IAGnFN,EAAMW,oBAAoBL,IAASN,EAAMY,2BAA2BN,KACjEJ,EAAajF,gCAA+BiF,EAAajF,8BAAgC,IAC9FiF,EAAajF,8BAA8BqF,GAAQN,EAAM/E,8BAA8BqF,IAGzF,IAAItE,EAAqBgE,EAAMa,sBAAsBP,GAChD3C,EAAQ3B,KACNkE,EAAalE,qBAAoBkE,EAAalE,mBAAqB,IACxEkE,EAAalE,mBAAmBsE,GAAQN,EAAMhE,mBAAmBsE,QAIhE3C,EAAQqC,EAAMhE,sBACjBkE,EAAalE,mBAAqBgE,EAAMhE,oBAErC2B,EAAQqC,EAAMlF,qBAAoBoF,EAAapF,kBAAoBkF,EAAMlF,mBACzE6C,EAAQqC,EAAMtF,gCACjBwF,EAAaxF,6BAA+BsF,EAAMtF,8BAE/CiD,EAAQqC,EAAM/E,iCACjBiF,EAAajF,8BAAgC+E,EAAM/E,gCAIvD,IAAI6F,EAAmBlD,EACrBqC,GACA,SAAStB,GACP,OAAoC,IAA7BA,EAAEU,QAAQ,iBAWrB,OAPAQ,EACEiB,GACA,SAASC,GACPb,EAAaa,GAAgBf,EAAMe,MAIhCb,EAGTlH,EAAOC,QAAU8G,G,oCCjEjB,IAAIiB,EAAO,EAAQ,QACfC,EAAS,EAAQ,QAYrB,SAASC,EAAcC,EAAYC,GACjCC,KAAKC,KAAOH,EACZE,KAAKD,GAAKA,EACVC,KAAKE,YAAc,KAGrBP,EAAKQ,SAASN,EAAeD,EAAOQ,cAOpCP,EAAcQ,UAAUC,OAAS,WAC/BN,KAAKO,qBACLP,KAAKC,KAAKO,oBAAoBR,OAGhCH,EAAcQ,UAAUI,iBAAmB,SAASC,GAClD,OAAOV,KAAKD,GAAGW,IAGjB/I,EAAOC,QAAUiI,G,qBCpCjB,IAAIc,EAAU,EAAQ,QAEtBhJ,EAAOC,QAAU,SAASgJ,EAAMC,GAC9B,IAAIC,EAAUC,MAAMV,UAAUW,MAAMC,KAAKC,WAczC,OAZAP,EAAQG,GAAS,SAASK,GACxB,IAAK,IAAIC,KAAWD,EACdA,EAAOE,eAAeD,KACY,kBAAzBP,EAAYO,IAAoD,kBAApBD,EAAOC,GAC5DP,EAAYO,GAAWR,EAAM,GAAIC,EAAYO,GAAUD,EAAOC,SACjCE,IAApBH,EAAOC,KAChBP,EAAYO,GAAWD,EAAOC,QAM/BP,I,uBCjBTlJ,EAAOC,QAAU,SAAc2J,EAAKC,GAClC,IAAIhJ,EAAO,EAAQ,QACfmI,EAAU,EAAQ,QAElBc,EAAW,GAQf,OANAd,EAAQnI,EAAK+I,IAAM,SAAkBH,IACb,IAAlBI,EAAKJ,KACPK,EAASL,GAAWG,EAAIH,OAIrBK,I,oCCVT,IAAIC,EAAS,EAAQ,QACjBC,EAAUD,EAAOC,SAAW,EAAQ,QAAeA,QAKvDhK,EAAOC,QAAU,SAA6BgK,EAAeC,GAC3D,IAAI1B,EAAW,EAAQ,QACnB2B,EAAS,EAAQ,QACjBC,EAAgB,EAAQ,QACxBC,EAAe,EAAQ,QACvBC,EAAS,EAAQ,QAOrB,SAASC,EAAcC,EAAeC,EAAQC,GAC5C,IAAIC,EAAY,EAAQ,QAMxB,OAJAD,EAAOC,EAAUD,GAAQ,IAEzBA,EAAKE,IAAMF,EAAKE,KAAOL,EAAcM,GAE9B,IAAIC,EAAqBN,EAAeC,EAAQC,GAbzDR,EAAWA,GAAY,GAgBvBK,EAAcQ,QAAU,EAAQ,QAChCR,EAAcM,GAAK,kCAAoCX,EAAWK,EAAcQ,QAChFR,EAAcS,WAAaV,EAAOC,GAIlCR,EAAOkB,UAAY,CACjBC,MAAO,EAAQ,QACfX,cAAeA,GAGjB,IAAIY,EAAU,CACZC,kBAAmB,mBAAoBrB,EACvCsB,kBAAmB,mBAAoBtB,GAOzC,SAASe,IAEPb,EAAcqB,MAAMjD,KAAMkB,WAmL5B,OAzLI4B,EAAQC,oBACVD,EAAQI,KAAO,oBAAqB,IAAIC,gBAQ1ChD,EAASsC,EAAsBb,GAE/Ba,EAAqBpC,UAAU+C,SAAW,SAAiBC,EAAKhB,GAC9D,OAAO,IAAIV,GAAQ,SAAqB2B,EAASC,GAE/C,GAAKT,EAAQI,MAASJ,EAAQE,kBAA9B,CAMAK,EAAMtB,EAAcsB,EAAKhB,EAAKmB,SAE9B,IAEIC,EACAC,EAHAC,EAAOtB,EAAKsB,KACZC,EAAMd,EAAQI,KAAO,IAAIC,eAAmB,IAAIU,eAGhDC,GAAY,EAEhBL,EAAaM,WAAWC,EAAW3B,EAAK4B,SAASC,SAMjDN,EAAIO,WAAaC,EACb,uBAAwBR,IAAKA,EAAIS,mBAAqBC,GAC1DV,EAAIW,OAASC,EACbZ,EAAIa,QAAUC,EAIVd,aAAeT,gBACjBS,EAAIe,KAAKtC,EAAKuC,OAAQvB,GAAK,GAIvBhB,EAAKwC,mBACPjB,EAAIkB,iBACF,2BACAzC,EAAKmB,QAAQ,6BAEfI,EAAIkB,iBACF,oBACAzC,EAAKmB,QAAQ,wBAIjBI,EAAIe,KAAKtC,EAAKuC,OAAQvB,GAIpBP,EAAQI,OACNS,IACkB,SAAhBtB,EAAKuC,OAEPhB,EAAIkB,iBAAiB,eAAgB,qCAErClB,EAAIkB,iBAAiB,eAAgB,qBAGzClB,EAAIkB,iBAAiB,SAAU,qBAG7BnB,EACFC,EAAImB,KAAKpB,GAETC,EAAImB,YA5DJxB,EAAO,IAAIzB,EAAOkD,QAAQ,uBAiE5B,SAASR,IAGP,IAAId,EAAJ,CAMA,IAAI3L,EAFJkN,aAAaxB,GAIb,IACE1L,EAAM,CACJ4L,KAAMuB,KAAKC,MAAMvB,EAAIwB,cACrBA,aAAcxB,EAAIwB,aAClBC,WAAYzB,EAAI0B,OAEhB9B,QAASI,EAAI2B,uBAAyB3B,EAAI2B,yBAA2B,IAEvE,MAAOC,GACPzN,EAAM,IAAI+J,EAAO2D,eAAe,CAC9BC,KAAM9B,EAAIwB,eAIVrN,aAAe+J,EAAO2D,eACxBlC,EAAOxL,GAEPuL,EAAQvL,IAIZ,SAAS2M,EAAQiB,GACXjC,IAIJuB,aAAaxB,GAKbF,EACE,IAAIzB,EAAOkD,QAAQ,CACjBU,KAAMC,MAKZ,SAAS3B,IACPN,GAAW,EACXE,EAAIgC,QAEJrC,EAAO,IAAIzB,EAAO+D,gBAGpB,SAASC,IACPhC,GAAY,EACZmB,aAAaxB,GACbA,EAAaM,WAAWC,EAAW3B,EAAK4B,SAAS8B,UAGnD,SAAS3B,IACFN,GAAWgC,IAGlB,SAASxB,KACFR,GAAaF,EAAIoC,WAAa,GAAGF,SAK5CrD,EAAqBpC,UAAU+C,SAAS6C,SAAW,SAAyB5C,EAAKhB,GAG/E,OAFAgB,EAAMtB,EAAcsB,EAAKhB,EAAKmB,SAEvB,IAAI7B,GAAQ,SAA0B2B,EAASC,GACpDvB,EAAaqB,EAAKhB,GAAM,SAA0B6D,EAAKC,GACjDD,EACF3C,EAAO2C,GAIT5C,EAAQ6C,UAKd1D,EAAqBpC,UAAU+F,SAAW,CACxC7C,OAAQ,SAAuB8C,GAC7B,OAAO1E,EAAQ4B,OAAO8C,IAExB/C,QAAS,SAAwB+C,GAC/B,OAAO1E,EAAQ2B,QAAQ+C,IAEzBC,MAAO,SAAsBC,GAC3B,OAAO,IAAI5E,GAAQ,SAA0B2B,GAC3CS,WAAWT,EAASiD,OAGxBC,IAAK,SAAaC,GAChB,OAAO9E,EAAQ6E,IAAIC,KAIhBvE,I,oCCrOT,IAAIwE,EAAsB,EAAQ,QAE9BC,EAAmB,EAAQ,QAC3BC,EAAgB,EAAQ,QAgC5B,SAASC,EAAoBC,EAAQ5M,EAAOmI,GAC1C,OAAO,IAAIqE,EAAoBI,EAAQ5M,EAAOmI,GAQhDwE,EAAoBnE,QAAU,EAAQ,QAOtCmE,EAAoBH,oBAAsBA,EAO1CG,EAAoBF,iBAAmBA,EAOvCE,EAAoBD,cAAgBA,EASpCC,EAAoBxD,IAAM,EAAQ,QAElC1L,EAAOC,QAAUiP,G,oCC5EjB,IAAIrO,EAAO,EAAQ,QACfuO,EAAe,EAAQ,QACvBC,EAAS,EAAQ,QACjBxI,EAAU,EAAQ,QAClBjC,EAAS,EAAQ,QACjBkC,EAAM,EAAQ,QACdjH,EAAS,EAAQ,QACjBgF,EAAO,EAAQ,QACfwB,EAAU,EAAQ,QAClBiJ,EAAQ,EAAQ,QAChB3K,EAAU,EAAQ,QAClB4K,EAAU,EAAQ,QAClB/K,EAAc,EAAQ,QACtBC,EAAW,EAAQ,QACnBC,EAAa,EAAQ,QACrB5E,EAAO,EAAQ,QACf0P,EAAO,EAAQ,QAEfrP,EAAW,EAAQ,QACnB8I,EAAQ,EAAQ,SAEhBwG,EAAc,EAAQ,QAEtB1I,EAAc,EAAQ,QAEtB2I,EAAiB,EAAQ,QAU7B,SAASC,EAAUC,EAAOC,GACxB,OAAO/P,EAAK8P,GAAO,SAASE,GAC1B,OAAOP,EAAQO,EAAcD,MAmDjC,SAASb,EAAiBe,GACxB,IAAIC,EAASD,EAAgBf,EAAiBiB,cAAcF,GAAiB,GAM7E1H,KAAK9F,MAAQyN,EAAOzN,OAAS,GAQ7B8F,KAAKhF,MAAQ2M,EAAO3M,OAAS,GAS7BgF,KAAKtG,OAASiO,EAAOjO,QAAU,GAO/BsG,KAAK1G,kBAAoBqO,EAAOrO,mBAAqB,GASrD0G,KAAKnG,mBAAqB8N,EAAO9N,oBAAsB,GAevDmG,KAAKvG,kBAAoBkO,EAAOlO,mBAAqB,GAarDuG,KAAKxG,eAAiBmO,EAAOnO,gBAAkB,GAa/CwG,KAAK3G,6BAA+BsO,EAAOtO,8BAAgC,GAY3E2G,KAAKrF,mBAAqBgN,EAAOhN,oBAAsB,GAQvDqF,KAAK1E,eAAiBqM,EAAOrM,gBAAkB,GAe/C0E,KAAKpG,8BAAgC+N,EAAO/N,+BAAiC,GAQ7EoG,KAAKtF,eAAiBiN,EAAOjN,eAS7BsF,KAAK3E,WAAasM,EAAOtM,WAOzB2E,KAAKxE,mBAAqBmM,EAAOnM,mBAOjCwE,KAAKvE,qBAAuBkM,EAAOlM,qBASnCuE,KAAKhG,YAAc2N,EAAO3N,YAM1BgG,KAAK3F,kBAAoBsN,EAAOtN,kBAMhC2F,KAAKlF,KAAO6M,EAAO7M,MAAQ,EAO3BkF,KAAKjF,UAAY4M,EAAO5M,UAOxBiF,KAAKzE,cAAgBoM,EAAOpM,cAO5ByE,KAAKxF,oBAAsBmN,EAAOnN,oBAMlCwF,KAAKvF,qBAAuBkN,EAAOlN,qBAKnCuF,KAAKzF,aAAeoN,EAAOpN,aAM3ByF,KAAKrH,0BAA4BgP,EAAOhP,0BAMxCqH,KAAK/F,cAAgB0N,EAAO1N,cAM5B+F,KAAK7E,6BAA+BwM,EAAOxM,6BAM3C6E,KAAKtH,eAAiBiP,EAAOjP,eAM7BsH,KAAKnH,UAAY8O,EAAO9O,UAMxBmH,KAAKpH,cAAgB+O,EAAO/O,cAM5BoH,KAAK5E,SAAWuM,EAAOvM,SAMvB4E,KAAK9E,2BAA6ByM,EAAOzM,2BAMzC8E,KAAKnF,cAAgB8M,EAAO9M,cAM5BmF,KAAK/E,uBAAyB0M,EAAO1M,uBAMrC+E,KAAK7G,qBAAuBwO,EAAOxO,qBAMnC6G,KAAK9G,sBAAwByO,EAAOzO,sBAMpC8G,KAAKjG,gBAAkB4N,EAAO5N,gBAM9BiG,KAAKlG,iBAAmB6N,EAAO7N,iBAM/BkG,KAAK5G,oBAAsBuO,EAAOvO,oBAMlC4G,KAAKrG,eAAiBgO,EAAOhO,eAM7BqG,KAAKzG,SAAWoO,EAAOpO,SAMvByG,KAAKjH,aAAe4O,EAAO5O,aAM3BiH,KAAKlH,kBAAoB6O,EAAO7O,kBAMhCkH,KAAK/G,aAAe0O,EAAO1O,aAM3B+G,KAAK1F,oBAAsBqN,EAAOrN,oBAMlC0F,KAAKhH,gBAAkB2O,EAAO3O,gBAM9BgH,KAAK7F,kBAAoBwN,EAAOxN,kBAMhC6F,KAAK5F,cAAgBuN,EAAOvN,cAQ5B4F,KAAKtE,oBAAsBiM,EAAOjM,oBASlCsE,KAAKrE,yBAA2BgM,EAAOhM,yBASvCqE,KAAKpE,6BAA+B+L,EAAO/L,6BAG3CoE,KAAKpF,OAAS+M,EAAO/M,OACrBoF,KAAK7H,OAASwP,EAAOxP,OAErB,IAAI0P,EAAO7H,KACXgH,EAAOW,GAAQ,SAAkCG,EAAYC,IACH,IAApDpB,EAAiBqB,WAAWhK,QAAQ+J,KACtCF,EAAKE,GAAaD,MAUxBnB,EAAiBqB,WAAaxP,EAAK,IAAImO,GAOvCA,EAAiBiB,cAAgB,SAAS/I,GAExC,GAAIA,aAAwB8H,EAAkB,OAAO9H,EAErD,IAAIoJ,EAAU,GAEVC,EAAa,CACf,kBACA,eACA,iBACA,uBACA,sBACA,OACA,oBACA,WACA,sBACA,cACA,gBAqBF,GAlBA1J,EAAQ0J,GAAY,SAASC,GAC3B,IAAItL,EAAQgC,EAAasJ,GACzB,GAAI/L,EAASS,GAAQ,CACnB,IAAIuL,EAAcC,WAAWxL,GAC7BoL,EAAQE,GAAKlB,EAAMmB,GAAevL,EAAQuL,MAM1CrH,MAAMuH,QAAQzJ,EAAa1E,qBAC7B8N,EAAQ9N,kBAAoB0E,EAAa1E,kBAAkBsE,KAAI,SAAS8J,GACtE,OAAOA,EAAQ9J,KAAI,SAAS5B,GAC1B,OAAOwL,WAAWxL,UAKpBgC,EAAalE,mBAAoB,CACnC,IAAIA,EAAqB,GACzB6D,EAAQK,EAAalE,oBAAoB,SAAS6N,EAAW5L,GAC3DjC,EAAmBiC,GAAa,GAChC4B,EAAQgK,GAAW,SAAS3K,EAAQ4K,GAClC,IAAIC,EAAejK,EAAIZ,GAAQ,SAASR,GACtC,OAAI0D,MAAMuH,QAAQjL,GACToB,EAAIpB,GAAG,SAASsL,GACrB,OAAIvM,EAASuM,GACJN,WAAWM,GAEbA,KAEAvM,EAASiB,GACXgL,WAAWhL,GAEbA,KAET1C,EAAmBiC,GAAW6L,GAAYC,QAG9CT,EAAQtN,mBAAqBA,EAG/B,OAAOiG,EAAM,GAAI/B,EAAcoJ,IASjCtB,EAAiBiC,KAAO,SAA8BlB,GACpD,IAAImB,EAAW,IAAIlC,EAAiBe,GAkBpC,OAhBAlJ,EAAQkJ,EAAc7N,oBAAoB,SAASiP,GACjD,GAAIA,EAAMC,SAAU,CAClB,IAAIC,EAAoBH,EAASI,0BAA0BH,EAAMI,MAE7DF,EAAkB7Q,OAAS,GAAsD,IAAjD6Q,EAAkB,GAAGhL,QAAQ8K,EAAMC,YACrEF,EAAWA,EAASM,iBAAiBL,EAAMI,OAI7CF,EAAoBH,EAASI,0BAA0BH,EAAMI,MAC5B,IAA7BF,EAAkB7Q,SACpB0Q,EAAWA,EAASO,kCAAkCN,EAAMI,KAAMJ,EAAMC,eAKvEF,GASTlC,EAAiB0C,SAAW,SAASC,EAAc5I,GACjD,IAAIiH,EAASjH,GAAc,GAE3B,OAAI4I,EAAajO,YAAcsM,EAAOrM,gBAAkBqM,EAAOrM,eAAenD,OAAS,EAC9E,IAAIqF,MACT,qLAIA8L,EAAahO,eAAenD,OAAS,GAAKwP,EAAOtM,WAC5C,IAAImC,MACT,oKAIA8L,EAAa5O,gBAAkBiN,EAAOhN,qBAAuB2B,EAAQqL,EAAOhN,oBACvE,IAAI6C,MACT,gLAKClB,EAAQgN,EAAa3O,qBAAuBgN,EAAOjN,eAC/C,IAAI8C,MACT,+KAKG,MAGTmJ,EAAiBtG,UAAY,CAC3BkJ,YAAa5C,EAWbwC,iBAAkB,SAA0BvM,GAC1C,IAAI4M,EAAQnC,EAAejK,gBACvBqM,EAAQ,CACV9O,mBAAoBqF,KAAK0J,yBAAyB9M,GAClDnD,kBAAmB+P,EAAMxJ,KAAKvG,kBAAmBmD,EAAW,oBAC5DpD,eAAgBgQ,EAAMxJ,KAAKxG,eAAgBoD,EAAW,WACtDvD,6BAA8BmQ,EAAMxJ,KAAK3G,6BAA8BuD,EAAW,oBAClFhD,8BAA+B4P,EAAMxJ,KAAKpG,8BAA+BgD,EAAW,sBAEtF,OAAI6M,EAAM9O,qBAAuBqF,KAAKrF,oBAClC8O,EAAMhQ,oBAAsBuG,KAAKvG,mBACjCgQ,EAAMjQ,iBAAmBwG,KAAKxG,gBAC9BiQ,EAAMpQ,+BAAiC2G,KAAK3G,8BAC5CoQ,EAAM7P,gCAAkCoG,KAAKpG,8BACxCoG,KAEFA,KAAK2J,mBAAmBF,IAOjCG,UAAW,WACT,YAAwBtI,IAApBtB,KAAK3E,YAA2D,IAA/B2E,KAAK1E,eAAenD,OAAqB6H,KAEvEA,KAAK2J,mBAAmB,CAC7BtO,gBAAYiG,EACZhG,eAAgB,MASpBuO,SAAU,SAAkB3P,GAC1B,OAAIA,IAAU8F,KAAK9F,MAAc8F,KAE1BA,KAAK2J,mBAAmB,CAC7BzP,MAAOA,KASX4P,SAAU,SAAkBC,GAC1B,OAAIA,IAAa/J,KAAKhF,MAAcgF,KAE7BA,KAAK2J,mBAAmB,CAC7B3O,MAAO+O,KASXC,QAAS,SAAiBC,GACxB,OAAIA,IAAYjK,KAAKlF,KAAakF,KAE3BA,KAAK2J,mBAAmB,CAC7B7O,KAAMmP,KAUVC,UAAW,SAAmBxQ,GAC5B,OAAOsG,KAAK2J,mBAAmB,CAC7BjQ,OAAQA,KAUZyQ,qBAAsB,SAA8BzQ,GAClD,OAAOsG,KAAK2J,mBAAmB,CAC7BrQ,kBAAmBI,KAUvB0Q,eAAgB,SAAwBC,GACtC,OAAIrK,KAAKhG,cAAgBqQ,EAAUrK,KAE5BA,KAAK2J,mBAAmB,CAC7B3P,YAAaqQ,KAUjBC,iBAAkB,SAA0B/O,GAC1C,OAAIyE,KAAKzE,gBAAkBA,EAAsByE,KAE1CA,KAAK2J,mBAAmB,CAC7BpO,cAAeA,KAoBnBgP,qBAAsB,SAAS3N,EAAW6L,EAAUpL,GAClD,IAAIR,EAAQuK,EAAY/J,GAExB,GAAI2C,KAAKwK,iBAAiB5N,EAAW6L,EAAU5L,GAAQ,OAAOmD,KAE9D,IAAI9C,EAAM0D,EAAM,GAAIZ,KAAKrF,oBAazB,OAXAuC,EAAIN,GAAagE,EAAM,GAAI1D,EAAIN,IAE3BM,EAAIN,GAAW6L,IAEjBvL,EAAIN,GAAW6L,GAAYvL,EAAIN,GAAW6L,GAAUzH,QAEpD9D,EAAIN,GAAW6L,GAAUnQ,KAAKuE,IAE9BK,EAAIN,GAAW6L,GAAY,CAAC5L,GAGvBmD,KAAK2J,mBAAmB,CAC7BhP,mBAAoBuC,KAQxBuN,0BAA2B,SAASC,GAClC,IAAK1K,KAAKd,mBAAmBwL,GAC3B,MAAM,IAAIlN,MAAMkN,EAAY,uEAE9B,OAAO1K,KAAKvG,kBAAkBiR,IAAc,IAO9CC,0BAA2B,SAASD,GAClC,IAAK1K,KAAKZ,mBAAmBsL,GAC3B,MAAM,IAAIlN,MACRkN,EAAY,kFAGhB,OAAO1K,KAAK3G,6BAA6BqR,IAAc,IAOzDzB,0BAA2B,SAASyB,GAGlC,OAAO1K,KAAKpG,8BAA8B8Q,IAAc,IAO1DE,sBAAuB,SAASF,GAC9B,IAAK1K,KAAKd,mBAAmBwL,GAC3B,MAAM,IAAIlN,MAAMkN,EAAY,uEAE9B,OAAO1K,KAAKxG,eAAekR,IAAc,IAW3CG,wBAAyB,SAASjO,EAAW6L,EAAUX,GACrD,QAAmBxG,IAAfwG,EAA0B,CAC5B,IAAIgD,EAAqB1D,EAAYU,GACrC,OAAK9H,KAAKwK,iBAAiB5N,EAAW6L,EAAUqC,GACzC9K,KAAK2J,mBAAmB,CAC7BhP,mBAAoBqF,KAAK0J,0BAAyB,SAAS7M,EAAOX,GAChE,OAAOA,IAAQU,GAAaC,EAAMkO,KAAOtC,GAAYvB,EAAQrK,EAAMwJ,IAAKyE,QAHA9K,KAMvE,YAAiBsB,IAAbmH,EACJzI,KAAKwK,iBAAiB5N,EAAW6L,GAC/BzI,KAAK2J,mBAAmB,CAC7BhP,mBAAoBqF,KAAK0J,0BAAyB,SAAS7M,EAAOX,GAChE,OAAOA,IAAQU,GAAaC,EAAMkO,KAAOtC,OAHWzI,KAQrDA,KAAKwK,iBAAiB5N,GACpBoD,KAAK2J,mBAAmB,CAC7BhP,mBAAoBqF,KAAK0J,0BAAyB,SAAS7M,EAAOX,GAChE,OAAOA,IAAQU,OAH2BoD,MAYhDR,sBAAuB,SAASkL,GAC9B,OAAO1K,KAAKrF,mBAAmB+P,IAAc,IAQ/CM,qBAAsB,SAASpO,EAAW6L,GACxC,OAAOzI,KAAKrF,mBAAmBiC,IAAcoD,KAAKrF,mBAAmBiC,GAAW6L,IAYlFiB,yBAA0B,SAAkC9M,GAC1D,GAAIT,EAAYS,GACd,OAAIN,EAAQ0D,KAAKrF,oBAA4BqF,KAAKrF,mBAC3C,GACF,GAAIyB,EAASQ,GAClB,OAAIN,EAAQ0D,KAAKrF,mBAAmBiC,IAAoBoD,KAAKrF,mBACtD6B,EAAKwD,KAAKrF,mBAAoBiC,GAChC,GAAIP,EAAWO,GAAY,CAChC,IAAIc,GAAa,EACbuN,EAAwBzT,EAAOwI,KAAKrF,oBAAoB,SAASiD,EAAM4K,EAAWtM,GACpF,IAAIgP,EAAe,GAiBnB,OAfA1M,EAAQgK,GAAW,SAAS3K,EAAQ4K,GAClC,IAAI0C,EAAY,GAChB3M,EAAQX,GAAQ,SAAShB,GACvB,IAAIuO,EAAkBxO,EAAU,CAACyJ,IAAKxJ,EAAOkO,GAAItC,GAAWvM,EAAK,WAC5DkP,GAAiBD,EAAU7S,KAAKuE,MAElCP,EAAQ6O,GAIRzN,GAAa,GAHZyN,EAAUhT,SAAW0F,EAAO1F,SAAQuF,GAAa,GACrDwN,EAAazC,GAAY0C,MAKxB7O,EAAQ4O,KAAetN,EAAK1B,GAAOgP,GAEjCtN,IACN,IAEH,OAAIF,EAAmBuN,EAChBjL,KAAKrF,qBAUhB0Q,SAAU,SAAkBvC,GAC1B,OAAI9I,KAAKd,mBAAmB4J,GACnB9I,KAGFA,KAAK2J,mBAAmB,CAC7BjQ,OAAQsG,KAAKtG,OAAOuD,OAAO,CAAC6L,OAUhCwC,oBAAqB,SAA6BxC,GAChD,OAAI9I,KAAKZ,mBAAmB0J,GACnB9I,KAGFA,KAAK2J,mBAAmB,CAC7BrQ,kBAAmB0G,KAAK1G,kBAAkB2D,OAAO,CAAC6L,OAWtDyC,qBAAsB,SAA8BC,GAClD,GAAIxL,KAAKV,oBAAoBkM,EAAkBtC,MAC7C,MAAM,IAAI1L,MACR,+DAAiEgO,EAAkBtC,KAAO,KAG9F,OAAOlJ,KAAK2J,mBAAmB,CAC7B9P,mBAAoBmG,KAAKnG,mBAAmBoD,OAAO,CAACuO,OAUxDC,mBAAoB,SAA4B3C,EAAOjM,GACrD,IAAKmD,KAAKd,mBAAmB4J,GAC3B,MAAM,IAAItL,MAAMsL,EAAQ,uEAE1B,OAAIzB,EAAevK,UAAUkD,KAAKvG,kBAAmBqP,EAAOjM,GAAemD,KAEpEA,KAAK2J,mBAAmB,CAC7BlQ,kBAAmB4N,EAAe3K,cAAcsD,KAAKvG,kBAAmBqP,EAAOjM,MAUnF6O,qBAAsB,SAA8B5C,EAAOjM,GACzD,IAAKmD,KAAKd,mBAAmB4J,GAC3B,MAAM,IAAItL,MAAMsL,EAAQ,uEAE1B,OAAIzB,EAAevK,UAAUkD,KAAKxG,eAAgBsP,EAAOjM,GAAemD,KAEjEA,KAAK2J,mBAAmB,CAC7BnQ,eAAgB6N,EAAe3K,cAAcsD,KAAKxG,eAAgBsP,EAAOjM,MAU7E8O,8BAA+B,SAAuC7C,EAAOjM,GAC3E,IAAKmD,KAAKZ,mBAAmB0J,GAC3B,MAAM,IAAItL,MACRsL,EAAQ,kFAGZ,OAAIzB,EAAevK,UAAUkD,KAAK3G,6BAA8ByP,EAAOjM,GAAemD,KAE/EA,KAAK2J,mBAAmB,CAC7BtQ,6BAA8BgO,EAAe3K,cAC3CsD,KAAK3G,6BAA8ByP,EAAOjM,MAQhD+O,iBAAkB,SAA0BC,GAC1C,GAAI7L,KAAK8L,aAAaD,GAAM,OAAO7L,KAEnC,IAAI+L,EAAe,CACjBzQ,eAAgB0E,KAAK1E,eAAe2B,OAAO4O,IAG7C,OAAO7L,KAAK2J,mBAAmBoC,IASjCC,YAAa,SAAqBlD,GAChC,OAAK9I,KAAKd,mBAAmB4J,GAItB9I,KAAKmJ,iBAAiBL,GAAOa,mBAAmB,CACrDjQ,OAAQ6C,EAAOyD,KAAKtG,QAAQ,SAAS4D,GACnC,OAAOA,IAAMwL,OALR9I,MAgBXiM,uBAAwB,SAAgCnD,GACtD,OAAK9I,KAAKZ,mBAAmB0J,GAItB9I,KAAKmJ,iBAAiBL,GAAOa,mBAAmB,CACrDrQ,kBAAmBiD,EAAOyD,KAAK1G,mBAAmB,SAASgE,GACzD,OAAOA,IAAMwL,OALR9I,MAgBXkM,wBAAyB,SAAiCpD,GACxD,OAAK9I,KAAKV,oBAAoBwJ,GAIvB9I,KAAKmJ,iBAAiBL,GAAOa,mBAAmB,CACrD9P,mBAAoB0C,EAAOyD,KAAKnG,oBAAoB,SAASyD,GAC3D,OAAOA,EAAE4L,OAASJ,OALb9I,MAkBXmM,sBAAuB,SAA+BrD,EAAOjM,GAC3D,IAAKmD,KAAKd,mBAAmB4J,GAC3B,MAAM,IAAItL,MAAMsL,EAAQ,uEAE1B,OAAKzB,EAAevK,UAAUkD,KAAKvG,kBAAmBqP,EAAOjM,GAEtDmD,KAAK2J,mBAAmB,CAC7BlQ,kBAAmB4N,EAAelK,iBAAiB6C,KAAKvG,kBAAmBqP,EAAOjM,KAHRmD,MAa9EoM,wBAAyB,SAAiCtD,EAAOjM,GAC/D,IAAKmD,KAAKd,mBAAmB4J,GAC3B,MAAM,IAAItL,MAAMsL,EAAQ,uEAE1B,OAAKzB,EAAevK,UAAUkD,KAAKxG,eAAgBsP,EAAOjM,GAEnDmD,KAAK2J,mBAAmB,CAC7BnQ,eAAgB6N,EAAelK,iBAAiB6C,KAAKxG,eAAgBsP,EAAOjM,KAHLmD,MAa3EqM,iCAAkC,SAA0CvD,EAAOjM,GACjF,IAAKmD,KAAKZ,mBAAmB0J,GAC3B,MAAM,IAAItL,MACRsL,EAAQ,kFAEZ,OAAKzB,EAAevK,UAAUkD,KAAK3G,6BAA8ByP,EAAOjM,GAEjEmD,KAAK2J,mBAAmB,CAC7BtQ,6BAA8BgO,EAAelK,iBAC3C6C,KAAK3G,6BAA8ByP,EAAOjM,KAJyCmD,MAazFsM,oBAAqB,SAA6BT,GAChD,IAAK7L,KAAK8L,aAAaD,GAAM,OAAO7L,KAEpC,IAAI+L,EAAe,CACjBzQ,eAAgBiB,EAAOyD,KAAK1E,gBAAgB,SAASiR,GAAK,OAAOA,IAAMV,MAGzE,OAAO7L,KAAK2J,mBAAmBoC,IAWjCxO,iBAAkB,SAA0BuL,EAAOjM,GACjD,OAAOmD,KAAKwM,sBAAsB1D,EAAOjM,IAU3C2P,sBAAuB,SAA+B1D,EAAOjM,GAC3D,GAAImD,KAAKV,oBAAoBwJ,GAC3B,OAAO9I,KAAKoJ,kCAAkCN,EAAOjM,GAChD,GAAImD,KAAKd,mBAAmB4J,GACjC,OAAO9I,KAAKyM,iCAAiC3D,EAAOjM,GAC/C,GAAImD,KAAKZ,mBAAmB0J,GACjC,OAAO9I,KAAK0M,iCAAiC5D,EAAOjM,GAGtD,MAAM,IAAIW,MAAM,sCAAwCsL,EACtD,+FASJ2D,iCAAkC,SAA0C3D,EAAOjM,GACjF,IAAKmD,KAAKd,mBAAmB4J,GAC3B,MAAM,IAAItL,MAAMsL,EAAQ,uEAG1B,OAAO9I,KAAK2J,mBAAmB,CAC7BlQ,kBAAmB4N,EAAe9J,iBAAiByC,KAAKvG,kBAAmBqP,EAAOjM,MAUtF8P,6BAA8B,SAAsC7D,EAAOjM,GACzE,IAAKmD,KAAKd,mBAAmB4J,GAC3B,MAAM,IAAItL,MAAMsL,EAAQ,uEAG1B,OAAO9I,KAAK2J,mBAAmB,CAC7BnQ,eAAgB6N,EAAe9J,iBAAiByC,KAAKxG,eAAgBsP,EAAOjM,MAUhF6P,iCAAkC,SAA0C5D,EAAOjM,GACjF,IAAKmD,KAAKZ,mBAAmB0J,GAC3B,MAAM,IAAItL,MACRsL,EAAQ,kFAGZ,OAAO9I,KAAK2J,mBAAmB,CAC7BtQ,6BAA8BgO,EAAe9J,iBAC3CyC,KAAK3G,6BAA8ByP,EAAOjM,MAUhDuM,kCAAmC,SAA2CN,EAAOjM,GACnF,IAAKmD,KAAKV,oBAAoBwJ,GAC5B,MAAM,IAAItL,MACRsL,EAAQ,mFAGZ,IAAI8D,EAAY5M,KAAK6M,+BAA+B7M,KAAK8M,2BAA2BhE,IAEhF5L,EAAM,GAEN6P,OAAqEzL,IAA9CtB,KAAKpG,8BAA8BkP,IAC5D9I,KAAKpG,8BAA8BkP,GAAO3Q,OAAS,IAGnD6H,KAAKpG,8BAA8BkP,GAAO,KAAOjM,GAK2B,IAA5EmD,KAAKpG,8BAA8BkP,GAAO,GAAG9K,QAAQnB,EAAQ+P,IAc/D,OAXIG,GACgC,IAA9BlQ,EAAMmB,QAAQ4O,GAEhB1P,EAAI4L,GAAS,GAEb5L,EAAI4L,GAAS,CAACjM,EAAMmE,MAAM,EAAGnE,EAAMmQ,YAAYJ,KAGjD1P,EAAI4L,GAAS,CAACjM,GAGTmD,KAAK2J,mBAAmB,CAC7B/P,8BAA+B9B,EAAS,GAAIoF,EAAK8C,KAAKpG,kCAW1DqT,+BAAgC,SAASnE,EAAOoE,GAC9C,GAAIlN,KAAKT,2BAA2BuJ,GAClC,MAAM,IAAItL,MAAMsL,EAAQ,wBAE1B,IAAI5L,EAAM,GAEV,OADAA,EAAI4L,GAAS,CAACoE,GACPlN,KAAK2J,mBAAmB,CAC7B/P,8BAA+B9B,EAAS,GAAIoF,EAAK8C,KAAKpG,kCAU1DuT,kCAAmC,SAASrE,GAC1C,IAAK9I,KAAKT,2BAA2BuJ,GACnC,MAAM,IAAItL,MAAMsL,EAAQ,oBAE1B,IAAI5L,EAAM,GAEV,OADAA,EAAI4L,GAAS,GACN9I,KAAK2J,mBAAmB,CAC7B/P,8BAA+B9B,EAAS,GAAIoF,EAAK8C,KAAKpG,kCAS1DwT,oBAAqB,SAA6BvB,GAChD,OAAI7L,KAAK8L,aAAaD,GACb7L,KAAKsM,oBAAoBT,GAG3B7L,KAAK4L,iBAAiBC,IAQ/BzM,mBAAoB,SAAS0J,GAC3B,OAAO9K,EAAQgC,KAAK1G,kBAAmBwP,IAAU,GAQnDxJ,oBAAqB,SAASoL,GAC5B,YAAsDpJ,IAA/CtB,KAAK8M,2BAA2BpC,IAQzCxL,mBAAoB,SAAS4J,GAC3B,OAAO9K,EAAQgC,KAAKtG,OAAQoP,IAAU,GAWxC3J,eAAgB,SAAwB2J,EAAOjM,GAC7C,IAAKmD,KAAKd,mBAAmB4J,GAC3B,MAAM,IAAItL,MAAMsL,EAAQ,uEAE1B,OAAOzB,EAAevK,UAAUkD,KAAKvG,kBAAmBqP,EAAOjM,IAYjEwQ,iBAAkB,SAA0BvE,EAAOjM,GACjD,IAAKmD,KAAKd,mBAAmB4J,GAC3B,MAAM,IAAItL,MAAMsL,EAAQ,uEAE1B,OAAOzB,EAAevK,UAAUkD,KAAKxG,eAAgBsP,EAAOjM,IAW9DwC,0BAA2B,SAAmCyJ,EAAOjM,GACnE,IAAKmD,KAAKZ,mBAAmB0J,GAC3B,MAAM,IAAItL,MACRsL,EAAQ,kFAEZ,OAAOzB,EAAevK,UAAUkD,KAAK3G,6BAA8ByP,EAAOjM,IAW5E0C,2BAA4B,SAAoCuJ,EAAOjM,GACrE,IAAKmD,KAAKV,oBAAoBwJ,GAC5B,MAAM,IAAItL,MACRsL,EAAQ,mFAGZ,IAAIwE,EAActN,KAAKiJ,0BAA0BH,GAEjD,OAAKjM,GAImC,IAAjCmB,EAAQsP,EAAazQ,GAHnByQ,EAAYnV,OAAS,GAehCqS,iBAAkB,SAA0B5N,EAAW6L,EAAU5L,GAC/D,GAAIV,EAAYU,IAAUV,EAAYsM,GACpC,QAASzI,KAAKrF,mBAAmBiC,GAGnC,IAAI2Q,EAAoBvN,KAAKrF,mBAAmBiC,KAC7CT,EAAY6D,KAAKrF,mBAAmBiC,GAAW6L,IAElD,GAAItM,EAAYU,KAAW0Q,EACzB,OAAOA,EAGT,IAAInF,EAAchB,EAAYvK,GAC1B2Q,GAA2BrR,EAC7BmL,EAAUtH,KAAKrF,mBAAmBiC,GAAW6L,GAAWL,IAG1D,OAAOmF,GAAqBC,GAQ9B1B,aAAc,SAAsBD,GAClC,OAA8C,IAAvC7N,EAAQgC,KAAK1E,eAAgBuQ,IAStC4B,4BAA6B,WAE3B,IAAIC,EAAkC3G,EACpCvO,EAAKwH,KAAKrF,oBACVqF,KAAK1G,mBAGP,OAAOd,EAAKwH,KAAK3G,8BACd4D,OAAOyQ,GACPzQ,OAAO+C,KAAK2N,iCASjBA,6BAA8B,WAC5B,OAAO5G,EAGLtI,EAAIuB,KAAKnG,mBAAoB,QAC7BrB,EAAKwH,KAAKpG,iCAQdgU,8BAA+B,WAC7B,IAAIC,EAAgB7N,KAAKyN,8BAEzB,OAAOlR,EAAOyD,KAAK1G,mBAAmB,SAASgE,GAC7C,OAAsC,IAA/BU,EAAQ6P,EAAevQ,OAIlCwQ,kBAAmB,CACjB,QACA,SAAU,oBAAqB,oBAC/B,iBAAkB,+BAClB,qBAAsB,iBAAkB,qBAAsB,iCAEhEC,eAAgB,WACd,IAAID,EAAoB9N,KAAK8N,kBAEzBE,EAAc,GAQlB,OANAhH,EAAOhH,MAAM,SAAS8H,EAAYC,IACe,IAA3C/J,EAAQ8P,EAAmB/F,SAAoCzG,IAAfwG,IAClDkG,EAAYjG,GAAaD,MAItBkG,GAOTC,kBAAmB,SAA2BlG,GAC5C,IAAK/H,KAAKqB,eAAe0G,GACvB,MAAM,IAAIvK,MACR,cAAgBuK,EAAhB,2HAIJ,OAAO/H,KAAK+H,IAYdmG,kBAAmB,SAAsBC,EAAWtR,GAClD,GAAImD,KAAKmO,KAAetR,EAAO,OAAOmD,KAEtC,IAAI+L,EAAe,GAInB,OAFAA,EAAaoC,GAAatR,EAEnBmD,KAAK2J,mBAAmBoC,IAQjCpC,mBAAoB,SAA4BhC,GAC9C,IAAKA,EAAQ,OAAO3H,KAEpB,IAAIoO,EAAQzH,EAAiB0C,SAASrJ,KAAM2H,GAE5C,GAAIyG,EACF,MAAMA,EAGR,IAAIC,EAAe1H,EAAiBiB,cAAcD,GAElD,OAAO3H,KAAKsO,UAAS,SAAmBC,GACtC,IAAIC,EAAKhW,EAAKmP,GAMd,OAJAnJ,EAAQgQ,GAAI,SAASrG,GACnBoG,EAAYpG,GAAKkG,EAAalG,MAGzBoG,MAWXhS,OAAQ,SAASqC,GACf,OAAOF,EAAYsB,KAAMpB,IAU3B0P,SAAU,SAAkBvO,GAC1B,IAAI0O,EAAW,IAAIzO,KAAKuJ,YAAYvJ,MAGpC,OADAD,EAAG0O,EAAUzO,MACNyO,GAQTC,4BAA6B,SAASlD,GACpC,OAAOA,EAAkB3T,QAAU,CAAC,iBAAkB,aASxDgV,+BAAgC,SAASrB,GACvC,OAAOA,EAAkBoB,WAAa,OASxC+B,yBAA0B,SAASnD,GACjC,OAAOA,EAAkBzC,UAAY,MASvC6F,gCAAiC,SAASpD,GACxC,MAAiD,mBAAtCA,EAAkBqD,iBACpBrD,EAAkBqD,iBAU7B/B,2BAA4B,SAASgC,GACnC,OAAOrX,EACLuI,KAAKnG,mBACL,CAACqP,KAAM4F,KASXC,+BAAgC,SAASrE,GACvC,IAAK1K,KAAKV,oBAAoBoL,GAC5B,MAAM,IAAIlN,MACR,gEAAkEkN,EAAY,KAGlF,IAAIsE,EAAahP,KAAKiJ,0BAA0ByB,GAAW,GAC3D,IAAKsE,EAAY,MAAO,GAExB,IAAIpC,EAAY5M,KAAK6M,+BACnB7M,KAAK8M,2BAA2BpC,IAE9BwC,EAAO8B,EAAW9W,MAAM0U,GAC5B,OAAOnO,EAAIyO,EAAM/F,IAGnB8H,SAAU,WACR,OAAO/J,KAAKgK,UAAUlP,KAAM,KAAM,KAatCrI,EAAOC,QAAU+O,G,kCCnrDjB,IAAIxG,EAAW,EAAQ,QAEvB,SAASgP,EAAmBC,EAASC,GACnC,IAAI7Q,EAAU,EAAQ,QAElB4P,EAAQpO,KAG2B,oBAA5BxC,MAAM8R,kBACf9R,MAAM8R,kBAAkBtP,KAAMA,KAAKuJ,aAEnC6E,EAAMmB,OAAQ,IAAK/R,OAAS+R,OAAS,8CAGvCvP,KAAKkJ,KAAO,qBACZlJ,KAAKoP,QAAUA,GAAW,gBAEtBC,GACF7Q,EAAQ6Q,GAAiB,SAA0BxS,EAAOX,GACxDkS,EAAMlS,GAAOW,KAOnB,SAAS2S,EAAkBtG,EAAMkG,GAC/B,SAASK,IACP,IAAIC,EAAO3O,MAAMV,UAAUW,MAAMC,KAAKC,UAAW,GAG1B,kBAAZwO,EAAK,IACdA,EAAKC,QAAQP,GAGfD,EAAmBlM,MAAMjD,KAAM0P,GAC/B1P,KAAKkJ,KAAO,gBAAkBA,EAAO,QAKvC,OAFA/I,EAASsP,EAA0BN,GAE5BM,EAjBTtP,EAASgP,EAAoB3R,OAqB7B7F,EAAOC,QAAU,CACfuX,mBAAoBA,EACpB1J,eAAgB+J,EACd,iBACA,2EAEF3J,eAAgB2J,EACd,iBACA,8CAEFxK,QAASwK,EACP,UACA,2CAEFI,gBAAiBJ,EACf,kBACA,8DAEFK,iBAAkBL,EAChB,mBACA,yDAEFM,QAASN,EACP,UACA,2B,oCCzEJ7X,EAAOC,QAAUmK,EAEjB,IAAI9F,EAAS,EAAQ,QAErB,SAAS8F,EAAcsB,EAAKG,GAO1B,MANI,KAAKhC,KAAK6B,GACZA,GAAO,IAEPA,GAAO,IAGFA,EAAMpH,EAAOuH,K,qBCTtB7L,EAAOC,QAAU,SAAqBmI,EAAIgQ,GACxCA,EAAYhQ,EAAI,K,uBC6BlB,IAAIiQ,EASJ,SAASC,EAAYC,GACnB,IAAcC,EAAVC,EAAO,EAEX,IAAKD,KAAKD,EACRE,GAAUA,GAAQ,GAAKA,EAAQF,EAAUG,WAAWF,GACpDC,GAAQ,EAGV,OAAOxY,EAAQ0Y,OAAOC,KAAKC,IAAIJ,GAAQxY,EAAQ0Y,OAAOnY,QAWxD,SAASsY,EAAYP,GAEnB,SAASrN,IAEP,GAAKA,EAAM6N,QAAX,CAEA,IAAI7I,EAAOhF,EAGP8N,GAAQ,IAAIC,KACZrK,EAAKoK,GAAQX,GAAYW,GAC7B9I,EAAKgJ,KAAOtK,EACZsB,EAAKiJ,KAAOd,EACZnI,EAAK8I,KAAOA,EACZX,EAAWW,EAIX,IADA,IAAIjB,EAAO,IAAI3O,MAAMG,UAAU/I,QACtBgY,EAAI,EAAGA,EAAIT,EAAKvX,OAAQgY,IAC/BT,EAAKS,GAAKjP,UAAUiP,GAGtBT,EAAK,GAAK9X,EAAQmZ,OAAOrB,EAAK,IAE1B,kBAAoBA,EAAK,IAE3BA,EAAKC,QAAQ,MAIf,IAAIzV,EAAQ,EACZwV,EAAK,GAAKA,EAAK,GAAGnR,QAAQ,iBAAiB,SAASyS,EAAOC,GAEzD,GAAc,OAAVD,EAAgB,OAAOA,EAC3B9W,IACA,IAAIgX,EAAYtZ,EAAQuZ,WAAWF,GACnC,GAAI,oBAAsBC,EAAW,CACnC,IAAI7K,EAAMqJ,EAAKxV,GACf8W,EAAQE,EAAUjQ,KAAK4G,EAAMxB,GAG7BqJ,EAAK0B,OAAOlX,EAAO,GACnBA,IAEF,OAAO8W,KAITpZ,EAAQyZ,WAAWpQ,KAAK4G,EAAM6H,GAE9B,IAAI4B,EAAQzO,EAAM0O,KAAO3Z,EAAQ2Z,KAAOC,QAAQD,IAAIE,KAAKD,SACzDF,EAAMrO,MAAM4E,EAAM6H,IAapB,OAVA7M,EAAMqN,UAAYA,EAClBrN,EAAM6N,QAAU9Y,EAAQ8Y,QAAQR,GAChCrN,EAAM6O,UAAY9Z,EAAQ8Z,YAC1B7O,EAAM8O,MAAQ1B,EAAYC,GAGtB,oBAAsBtY,EAAQga,MAChCha,EAAQga,KAAK/O,GAGRA,EAWT,SAASgP,EAAOC,GACdla,EAAQma,KAAKD,GAEbla,EAAQoa,MAAQ,GAChBpa,EAAQqa,MAAQ,GAKhB,IAHA,IAAI/Z,GAA+B,kBAAf4Z,EAA0BA,EAAa,IAAI5Z,MAAM,UACjEga,EAAMha,EAAMC,OAEPgY,EAAI,EAAGA,EAAI+B,EAAK/B,IAClBjY,EAAMiY,KACX2B,EAAa5Z,EAAMiY,GAAG5R,QAAQ,MAAO,OACf,MAAlBuT,EAAW,GACbla,EAAQqa,MAAM3Z,KAAK,IAAI6Z,OAAO,IAAML,EAAWM,OAAO,GAAK,MAE3Dxa,EAAQoa,MAAM1Z,KAAK,IAAI6Z,OAAO,IAAML,EAAa,OAWvD,SAASO,IACPza,EAAQia,OAAO,IAWjB,SAASnB,EAAQxH,GACf,IAAIiH,EAAG+B,EACP,IAAK/B,EAAI,EAAG+B,EAAMta,EAAQqa,MAAM9Z,OAAQgY,EAAI+B,EAAK/B,IAC/C,GAAIvY,EAAQqa,MAAM9B,GAAG3O,KAAK0H,GACxB,OAAO,EAGX,IAAKiH,EAAI,EAAG+B,EAAMta,EAAQoa,MAAM7Z,OAAQgY,EAAI+B,EAAK/B,IAC/C,GAAIvY,EAAQoa,MAAM7B,GAAG3O,KAAK0H,GACxB,OAAO,EAGX,OAAO,EAWT,SAAS6H,EAAO1K,GACd,OAAIA,aAAe7I,MAAc6I,EAAIkJ,OAASlJ,EAAI+I,QAC3C/I,EAhMTzO,EAAUD,EAAOC,QAAU6Y,EAAY5N,MAAQ4N,EAAY,WAAaA,EACxE7Y,EAAQmZ,OAASA,EACjBnZ,EAAQya,QAAUA,EAClBza,EAAQia,OAASA,EACjBja,EAAQ8Y,QAAUA,EAClB9Y,EAAQ0a,SAAW,EAAQ,QAM3B1a,EAAQoa,MAAQ,GAChBpa,EAAQqa,MAAQ,GAQhBra,EAAQuZ,WAAa,I,wBC5BrB,gBAGIoB,EAHJ,EAAY,EAAQ,OAAR,CAAiB,uCACzBC,EAAwB,0BAGxBC,EAAc,CAChB9T,MAAO,GACP+T,IAAK,SAASxW,EAAKyW,GAEjB,OADA3S,KAAKrB,MAAMzC,GAAOyW,EACX3S,KAAKrB,MAAMzC,IAEpB0W,IAAK,SAAS1W,GACZ,OAAO8D,KAAKrB,MAAMzC,IAAQ,OAI1B2W,EAAoB,CACtBH,IAAK,SAASxW,EAAKyW,GACjBF,EAAYC,IAAIxW,EAAKyW,GAErB,IACE,IAAIzC,EAAYhL,KAAKC,MAAMzD,EAAOoR,aAAaN,IAG/C,OAFAtC,EAAUhU,GAAOyW,EACjBjR,EAAOoR,aAAaN,GAAyBtN,KAAKgK,UAAUgB,GACrDA,EAAUhU,GACjB,MAAOsJ,GACP,OAAOuN,EAAoB7W,EAAKsJ,KAGpCoN,IAAK,SAAS1W,GACZ,IACE,OAAOgJ,KAAKC,MAAMzD,EAAOoR,aAAaN,IAAwBtW,IAAQ,KACtE,MAAOsJ,GACP,OAAOuN,EAAoB7W,EAAKsJ,MAKtC,SAASuN,EAAoB7W,EAAKsJ,GAIhC,OAHA3C,EAAM,2BAA4B2C,GAClCwN,IACAT,EAAQE,EACDF,EAAMK,IAAI1W,GAWnB,SAAS+W,EAAS/W,EAAKyW,GACrB,OAAyB,IAArBzR,UAAU/I,OACLoa,EAAMK,IAAI1W,GAGZqW,EAAMG,IAAIxW,EAAKyW,GAGxB,SAASO,IACP,IACE,MAAI,iBAAkBxR,GACI,OAAxBA,EAAOoR,eACFpR,EAAOoR,aAAaN,IAEvB9Q,EAAOoR,aAAaK,QAAQX,EAAuBtN,KAAKgK,UAAU,MAE7D,GAIT,MAAOkE,GACP,OAAO,GAMX,SAASJ,IACP,IACEtR,EAAOoR,aAAaO,WAAWb,GAC/B,MAAOY,KAtCXb,EAAQW,IAAyBL,EAAoBJ,EAErD9a,EAAOC,QAAU,CACfgb,IAAKK,EACLP,IAAKO,EACLC,qBAAsBA,K,6CCjDxB,IAAII,EAAoB,EAAQ,QAC5BC,EAAY,EAAQ,QACpBC,EAAoB,EAAQ,QAQhC,SAASC,EAAUvR,EAAewR,GAChC1T,KAAK0T,UAAYA,EACjB1T,KAAK2T,GAAKzR,EACVlC,KAAK4T,cAAgB,KACrB5T,KAAK6T,qBAAuB,KAG5B7T,KAAK8T,MAAQ,GAbfnc,EAAOC,QAAU6b,EAmBjBA,EAAUpT,UAAU0T,WAAa,WAC/B/T,KAAK8T,MAAQ,IAkGfL,EAAUpT,UAAU2T,OAASV,EAAkB,SAY/CG,EAAUpT,UAAU4T,cAAgBV,EAClCD,EAAkB,gBAClBE,EACE,yCACA,sDAqBJC,EAAUpT,UAAU6T,OAAS,SAASlZ,EAAOmZ,EAAiBC,GAC5D,IAIItZ,EACAd,EALA4G,EAAQ,EAAQ,QAEhByT,EAAWrU,KAQU,IAArBkB,UAAU/I,QAAqC,IAArB+I,UAAU/I,QAAwC,oBAAjB+I,UAAU,IACvEpG,EAAO,EACPsZ,EAAWlT,UAAU,GACrBlG,OAAQsG,GACyB,kBAAjBJ,UAAU,IAE1BpG,EAAOoG,UAAU,GACW,kBAAjBA,UAAU,GACnBlH,EAAckH,UAAU,GACS,oBAAjBA,UAAU,KAC1BkT,EAAWlT,UAAU,GACrBlH,OAAcsH,GAEhBtG,OAAQsG,EACR6S,OAAkB7S,GACe,kBAAjBJ,UAAU,IAEE,oBAAjBA,UAAU,KACnBkT,EAAWlT,UAAU,IAEvBiT,EAAkBjT,UAAU,GAC5BlG,OAAQsG,GACyB,kBAAjBJ,UAAU,IAA2C,oBAAjBA,UAAU,KAE9DkT,EAAWlT,UAAU,GACrBiT,OAAkB7S,GAOpB6S,EAAkBvT,EAAM,GAAIuT,GAAmB,GAAI,CACjDrZ,KAAMA,EACNd,YAAaA,EACbgB,MAAOA,IAGT,IAAI2M,EAAS3H,KAAK2T,GAAGW,iBAAiBH,EAAiB,IAEvD,OAAOnU,KAAK2T,GAAGY,aAAa,CAC1B3P,OAAQ,OACRvB,IAAK,cAAgBmR,mBAAmBH,EAASX,WAAa,UAC9D/P,KAAM,CAACgE,OAAQA,GACf8M,SAAU,OACVL,SAAUA,KAiBdX,EAAUpT,UAAUqU,WAAa,SAASC,EAAQP,GAChD,OAAOpU,KAAK2T,GAAGY,aAAa,CAC1B3P,OAAQ,OACRvB,IAAK,cAAgBmR,mBAAmBxU,KAAK0T,WAAa,UAC1D/P,KAAM,CAACgR,OAAQA,GACfF,SAAU,OACVL,SAAUA,KAgBdX,EAAUpT,UAAUuU,qBAAuB,SAASjN,EAAQyM,GAC1D,IAAIS,EAAQ,EAAQ,QAChBrY,EAAO,EAAQ,QACfsY,EAAQ,oFAEZ,QAAyBxT,IAArBqG,EAAO+C,gBAAiDpJ,IAAtBqG,EAAOoN,WAC3C,MAAM,IAAIvX,MAAMsX,GAGlB,IAAIpK,EAAY/C,EAAO+C,UACnBsK,EAAiBxY,EAAKqY,EAAMlN,IAAS,SAASvG,GAChD,MAAmB,cAAZA,KAEL3B,EAAmBO,KAAK2T,GAAGW,iBAAiBU,EAAgB,IAEhE,OAAOhV,KAAK2T,GAAGY,aAAa,CAC1B3P,OAAQ,OACRvB,IAAK,cACHmR,mBAAmBxU,KAAK0T,WAAa,WAAac,mBAAmB9J,GAAa,SACpF+J,SAAU,OACV9Q,KAAM,CAACgE,OAAQlI,GACf2U,SAAUA,KAIdX,EAAUpT,UAAU4U,YAAc1B,GAAU,SAAS5L,EAAQyM,GAC3D,OAAOpU,KAAK4U,qBAAqBjN,EAAQyM,KACxCZ,EACD,wCACA,mDAGFC,EAAUpT,UAAU6U,QAAU,SAASvN,EAAQtE,EAAK+Q,EAAUe,GAC5D,OAAOnV,KAAK2T,GAAGY,aAAa,CAC1BT,MAAO9T,KAAK8T,MACZlP,OAAQ,OACRvB,IAAKA,GAAO,cAAgBmR,mBAAmBxU,KAAK0T,WAAa,SACjE/P,KAAM,CAACgE,OAAQA,GACf8M,SAAU,OACVxO,SAAU,CACRrB,OAAQ,MACRvB,IAAK,cAAgBmR,mBAAmBxU,KAAK0T,WAC7C/P,KAAM,CAACgE,OAAQA,IAEjByM,SAAUA,EACVe,aAAcA,KAalB1B,EAAUpT,UAAU+U,UAAY,SAASC,EAAUC,EAAOlB,GACxD,IAAIC,EAAWrU,KAEU,IAArBkB,UAAU/I,QAAiC,oBAAVmd,IACnClB,EAAWkB,EACXA,OAAQhU,GAGV,IAAIqG,EAAS,GACb,QAAcrG,IAAVgU,EAAqB,CACvB3N,EAAS,eACT,IAAK,IAAIwI,EAAI,EAAGA,EAAImF,EAAMnd,SAAUgY,EACxB,IAANA,IACFxI,GAAU,KAEZA,GAAU2N,EAAMnF,GAIpB,OAAOnQ,KAAK2T,GAAGY,aAAa,CAC1B3P,OAAQ,MACRvB,IAAK,cAAgBmR,mBAAmBH,EAASX,WAAa,IAAMc,mBAAmBa,GAAY1N,EACnG8M,SAAU,OACVL,SAAUA,KASdX,EAAUpT,UAAUkV,WAAa,SAASC,EAAWrc,EAAsBib,GACzE,IAAI9L,EAAU,EAAQ,QAClB7J,EAAM,EAAQ,QAEdqW,EAAQ,wDAEZ,IAAKxM,EAAQkN,GACX,MAAM,IAAIhY,MAAMsX,GAGlB,IAAIT,EAAWrU,KAEU,IAArBkB,UAAU/I,QAAgD,oBAAzBgB,IACnCib,EAAWjb,EACXA,OAAuBmI,GAGzB,IAAIqC,EAAO,CACT8R,SAAUhX,EAAI+W,GAAW,SAAwBH,GAC/C,IAAIK,EAAU,CACZhC,UAAWW,EAASX,UACpB2B,SAAUA,GAOZ,OAJIlc,IACFuc,EAAQvc,qBAAuBA,EAAqBwc,KAAK,MAGpDD,MAIX,OAAO1V,KAAK2T,GAAGY,aAAa,CAC1B3P,OAAQ,OACRvB,IAAK,uBACLoR,SAAU,OACV9Q,KAAMA,EACNyQ,SAAUA,KAIdX,EAAUpT,UAAUsT,GAAK,KACzBF,EAAUpT,UAAUqT,UAAY,KAChCD,EAAUpT,UAAUuT,cAAgB,KACpCH,EAAUpT,UAAUwT,qBAAuB,M,kCC5X3C,IAAI+B,EAAY,EAAQ,QACpBjP,EAAmB,EAAQ,QAE3BkP,EAAK,EAAQ,QAEbpE,EAAO,EAAQ,QACfjT,EAAU,EAAQ,QAClBsX,EAAO,EAAQ,QACfrX,EAAM,EAAQ,QACdsX,EAAU,EAAQ,QAClBC,EAAY,EAAQ,QACpB5Z,EAAW,EAAQ,QACnB6Z,EAAgB,EAAQ,QACxB3Z,EAAU,EAAQ,QAClB/D,EAAS,EAAQ,QAEjB0D,EAAS,EAAQ,QAAgBA,OAErC,SAASia,EAAgBC,GACvB,OAAIF,EAAcE,GACTH,EAAUG,EAAOD,GAEtBnV,MAAMuH,QAAQ6N,GACT1X,EAAI0X,EAAOD,GAEhB9Z,EAAS+Z,GACJla,EAAOka,GAETA,EAGT,IAAIC,EAAwB,CAAC,MAAO,KAAM,KAAM,MAAO,MACnDC,EAAYT,EAAU9Z,mBAC1B,SAASwa,EAAsBC,EAAcC,EAAiBC,EAAGC,GAS/D,GARqB,OAAjBH,IACFE,EAAIA,EAAElY,QAAQgY,EAAc,IAC5BG,EAAIA,EAAEnY,QAAQgY,EAAc,KAG9BE,EAAID,EAAgBC,IAAMA,EAC1BC,EAAIF,EAAgBE,IAAMA,GAEI,IAA1BL,EAAUrY,QAAQyY,KAAuC,IAA1BJ,EAAUrY,QAAQ0Y,GAAW,CAC9D,GAAU,MAAND,EAAW,OAAQ,EACvB,GAAU,MAANC,EAAW,OAAO,EAEtB,IAAIC,GAAuD,IAAtCP,EAAsBpY,QAAQyY,GAC/CG,GAAuD,IAAtCR,EAAsBpY,QAAQ0Y,GACnD,GAAIC,IAAmBC,EACrB,OAAO,EACF,GAAIA,IAAmBD,EAC5B,OAAQ,EAIZ,OAAOF,EAAEI,cAAcH,GAazB9e,EAAQkf,wBAA0B,SAASC,EAAaC,GACtD,IAAIC,EAAsBD,GAAWA,EAAQE,QAAU,GACnDC,EAAUH,GAAWA,EAAQG,SAAW,GACxCX,EAAkBje,EAAO4e,GAEzBC,EAAyBvB,EAAG1Q,MAAM4R,GAClCR,EAAe,IAAIpE,OAAO,IAAM8E,GAChCpY,EAAekX,EACjBqB,GACA,SAAS/Z,EAAG8K,GACV,IAAIkP,EAAYJ,GAAuBV,EAAa/U,KAAK2G,GACrDmP,EAAgBD,EAAYlP,EAAE5J,QAAQgY,EAAc,IAAMpO,EAC1DoP,EAAa3B,EAAU7Z,OAAOya,EAAgBc,IAAkBA,GACpE,OAAOC,GAAcD,KAIrBE,EAAgC7Q,EAAiBiB,cAAc/I,GAEnE,OAAOiX,EAAK0B,EAA+B7Q,EAAiBqB,aAa9DpQ,EAAQ6f,uCAAyC,SAASV,EAAaC,GACrE,IAAIC,EAAsBD,GAAWA,EAAQE,OACzCC,EAAUH,GAAWA,EAAQG,SAAW,GACxCX,EAAkBje,EAAO4e,GAEzBO,EAAgB,GAChBC,EAAS9B,EAAG1Q,MAAM4R,GACtB,GAAIE,EAAqB,CACvB,IAAIV,EAAe,IAAIpE,OAAO,IAAM8E,GACpCzY,EAAQmZ,GAAQ,SAASta,EAAGnB,GACrBqa,EAAa/U,KAAKtF,KAAMwb,EAAcxb,GAAOmB,WAGpDmB,EAAQmZ,GAAQ,SAASta,EAAGnB,GACrB0Z,EAAU7Z,OAAOya,EAAgBta,IAAQA,KAAMwb,EAAcxb,GAAOmB,MAI7E,OAAOqa,GAgBT9f,EAAQggB,wBAA0B,SAASjZ,EAAOqY,GAChD,IAAIa,EAAiBb,GAAWA,EAAQa,eACpCZ,EAAsBD,GAAWA,EAAQE,QAAU,GACnDC,EAAUH,GAAWA,EAAQG,SAAW,GACxCW,EAAOd,GAAWA,EAAQc,OAAQ,EAClCtB,EAAkBje,EAAO4e,GAEzBY,EAAcD,EAAOnZ,EAAQuX,EAAgBvX,GAE7CqZ,EAAejC,EACjBgC,GACA,SAAS1a,EAAG8K,GACV,IAAI8P,EAASrC,EAAU3Z,OAAOkM,GAC9B,OAAO8O,GAAuBE,EAAQc,IAAWA,MAIjD1B,EAAuC,KAAxBU,EAA6B,KAAO,IAAI9E,OAAO,IAAM8E,GACpEiB,EAAOzG,EAAK6E,EAAuB,KAAMC,EAAcC,GAC3D,IAAKla,EAAQub,GAAiB,CAC5B,IAAIM,EAAUtC,EAAG3G,UAAU8I,EAAc,CAAC/b,OAAQ6b,EAAMI,KAAMA,IAC1DE,EAASvC,EAAG3G,UAAU2I,EAAgB,CAAC5b,OAAQ6b,IACnD,OAAKK,EACEA,EAAU,IAAMC,EADFA,EAIvB,OAAOvC,EAAG3G,UAAU8I,EAAc,CAAC/b,OAAQ6b,EAAMI,KAAMA,M,oCCtKzDvgB,EAAOC,QAAUygB,EAEjB,IAAIC,EAAO,EAAQ,QACf7Z,EAAM,EAAQ,QACdjH,EAAS,EAAQ,QACjB+gB,EAAU,EAAQ,QAClBpR,EAAO,EAAQ,QACf1P,EAAO,EAAQ,QACf+gB,EAAS,EAAQ,QAEjBC,EAAiC,EAAQ,QAE7C,SAASJ,EAAc1Z,GACrB,OAAO,SAAkB+Z,EAAyBC,GAChD,IAAInN,EAAoB7M,EAAM9E,mBAAmB8e,GAC7CC,EAA8Bja,EAAM/E,8BAA8B4R,EAAkBtC,OACtFvK,EAAM/E,8BAA8B4R,EAAkBtC,MAAM,IAAM,GAChE2P,EAAwBla,EAAMkO,+BAA+BrB,GAC7DsN,EAAuBna,EAAMgQ,yBAAyBnD,GACtDuN,EAA8Bpa,EAAMiQ,gCAAgCpD,GACpE3T,EAAS4gB,EAA+B9Z,EAAM+P,4BAA4BlD,IAE1EwN,EAAiBC,EAAyBphB,EAAQghB,EAAuBC,EAC3EC,EAA6BH,GAE3BM,EAAUR,EAMd,OAJII,IACFI,EAAUR,EAAwB1X,MAAM8X,EAAqB5gB,MAAM2gB,GAAuB1gB,SAGrFX,EAAO0hB,EAASF,EAAgB,CACrC9P,KAAMvK,EAAM9E,mBAAmB8e,GAAwBzP,KACvDiQ,MAAO,KACPrc,WAAW,EACXoQ,KAAM,KACNyF,KAAM,QAKZ,SAASsG,EAAyBphB,EAAQghB,EAAuBC,EAC/BC,EAA6B/P,GAC7D,OAAO,SAAsBoQ,EAAkBV,EAAyBW,GACtE,IAAIC,EAASF,EAEb,GAAIC,EAA2B,EAAG,CAChC,IAAIE,EAAQ,EAEZD,EAASF,EAET,MAAOG,EAAQF,EACbC,EAASA,GAAU7hB,EAAK6hB,EAAO3G,KAAM,CAAC7V,WAAW,IACjDyc,IAKJ,GAAID,EAAQ,CAYV,IAAIE,EAAuBC,EAAkBH,EAAOpM,MAAQ4L,EAC1D9P,EAAmB6P,EAAuBC,EAAsBC,GAElEO,EAAO3G,KAAO4F,EACZ9Z,EACE+Z,EAAOE,EAAwB/F,KAAM6G,GACrCE,EAA6Bb,EAAuB7P,IAEtDnR,EAAO,GAAIA,EAAO,IAItB,OAAOuhB,GAIX,SAASK,EAAkBE,EAAY3Q,EAAmB6P,EAAuBC,EACtDC,GACzB,OAAO,SAASa,EAAYC,GAE1B,QAAIf,GAC4C,IAA7Ce,EAAW7b,QAAQ8a,IAA+BA,IAAyBe,MAKtEf,IAAuE,IAA/Ce,EAAW7b,QAAQ6a,IAEjDC,GACAe,EAAW3hB,MAAM2gB,GAAuB1gB,OAAS2gB,EAAqB5gB,MAAM2gB,GAAuB1gB,SAAW,IAG/D,IAA/C0hB,EAAW7b,QAAQ6a,KACmC,IAAtD7P,EAAkBhL,QAAQ6a,IAEgB,IAA1C7P,EAAkBhL,QAAQ6b,IAEiC,IAA3DA,EAAW7b,QAAQ2b,EAAad,KAC/BE,GAAyE,IAA1Cc,EAAW7b,QAAQgL,MAIzD,SAAS0Q,EAA6Bb,EAAuB7P,GAC3D,OAAO,SAAgB4Q,EAAYC,GACjC,MAAO,CACL3Q,KAAM/B,EAAKmR,EAAKuB,EAAW3hB,MAAM2gB,KACjC3L,KAAM2M,EACNV,MAAOS,EACP9c,UAAWkM,IAAsB6Q,GAAgF,IAAlE7Q,EAAkBhL,QAAQ6b,EAAahB,GACtFlG,KAAM,S,qBCzHZhb,EAAOC,QAAU,SAAmBmI,EAAIqP,GACtC,IAAI0K,GAAS,EAEb,SAASC,IAOP,OANKD,IAEHtI,QAAQwI,KAAK5K,GACb0K,GAAS,GAGJ/Z,EAAGkD,MAAMjD,KAAMkB,WAGxB,OAAO6Y,I,oCCXT,IAAItb,EAAM,EAAQ,QACdwb,EAAW,EAAQ,QACnB7d,EAAW,EAAQ,QACvB,SAASgL,EAAY/J,GACnB,GAAI4c,EAAS5c,GACX,OAAOA,EACF,GAAIjB,EAASiB,GAClB,OAAOgL,WAAWhL,GACb,GAAI0D,MAAMuH,QAAQjL,GACvB,OAAOoB,EAAIpB,EAAG+J,GAGhB,MAAM,IAAI5J,MAAM,0EAGlB7F,EAAOC,QAAUwP,G,mBCjBjBzP,EAAOC,QAAU,SAAe2J,GAC9B,OAAO2D,KAAKC,MAAMD,KAAKgK,UAAU3N,M,kCCCnC,IAAI/C,EAAU,EAAQ,QAClB0b,EAAU,EAAQ,QAClBlc,EAAU,EAAQ,QAClBmc,EAAY,EAAQ,QACpBvH,EAAM,EAAQ,QAEdwH,EAAQ,EAAQ,QAChB3iB,EAAO,EAAQ,QACf4iB,EAAW,EAAQ,QACnB5b,EAAM,EAAQ,QACd8Z,EAAU,EAAQ,QAElBzgB,EAAW,EAAQ,QACnB8I,EAAQ,EAAQ,SAEhBvE,EAAa,EAAQ,QAErBie,EAAU,EAAQ,QAClBC,EAAe,EAAQ,QAEvBC,EAAa,EAAQ,QAErBvB,EAA2B,EAAQ,QA2CvC,SAASwB,EAAWlZ,GAClB,IAAImZ,EAAU,GAId,OAFAlc,EAAQ+C,GAAK,SAAS8E,EAAKsU,GAAOD,EAAQrU,GAAOsU,KAE1CD,EAGT,SAASE,EAAiBC,EAAMC,EAAY5e,GACtC4e,GAAcA,EAAW5e,KAC3B2e,EAAKE,MAAQD,EAAW5e,IAI5B,SAAS8e,EAA+CnhB,EAAoBohB,GAC1E,OAAOxjB,EACLoC,GACA,SAAkC2R,GAChC,OAAO6O,EAAS7O,EAAkBzM,WAAYkc,MAyIpD,SAASrU,EAAcjI,EAAOua,GAC5B,IAAIgC,EAAkBhC,EAAQ,GAE9BlZ,KAAKmb,YAAcjC,EAMnBlZ,KAAKhF,MAAQkgB,EAAgBlgB,MAK7BgF,KAAKob,YAAcF,EAAgBE,YASnCpb,KAAKqb,KAAOH,EAAgBG,KAK5Brb,KAAK9F,MAAQghB,EAAgBhhB,MAK7B8F,KAAKhG,YAAckhB,EAAgBlhB,YAKnCgG,KAAKsb,OAASJ,EAAgBI,OAK9Btb,KAAKub,QAAUL,EAAgBK,QAK/Bvb,KAAKlF,KAAOogB,EAAgBpgB,KAK5BkF,KAAKwb,iBAAmBpB,EAAMlB,EAAS,oBAMvClZ,KAAKjH,aAAemiB,EAAgBniB,aAMpCiH,KAAKyb,gBAAkBP,EAAgBO,gBAMvCzb,KAAK0b,WAAaR,EAAgBQ,WAMlC1b,KAAK2b,cAAgBT,EAAgBS,cAMrC3b,KAAK4b,YAAcV,EAAgBU,YAMnC5b,KAAK6b,sBAAwBX,EAAgBW,sBAM7C7b,KAAK8b,iBAAmBZ,EAAgBY,iBAOxC9b,KAAK+b,SAAWb,EAAgBa,SAOhC/b,KAAKgc,QAAUd,EAAgBc,QAM/Bhc,KAAK1G,kBAAoB,GAKzB0G,KAAKnG,mBAAqB4E,EAAIE,EAAM9E,oBAAoB,WACtD,MAAO,MAMTmG,KAAKtG,OAAS,GAEd,IAAIJ,EAAoBqF,EAAM8O,8BAE1BwO,EAAgBxB,EAAW9b,EAAMjF,QACjCwiB,EAA2BzB,EAAW9b,EAAMrF,mBAC5C6iB,EAAwB,EAExBtU,EAAO7H,KAGXxB,EAAQ0c,EAAgBxhB,QAAQ,SAAS0iB,EAAkBC,GACzD,IAAI7Q,EAAoBwP,EACtBrc,EAAM9E,mBACNwiB,GAGF,GAAI7Q,EAAmB,CAGrB,IAAI8Q,EAAa9Q,EAAkBzM,WAAWf,QAAQqe,GAClDE,EAAmBpC,EAAUxb,EAAM9E,mBAAoB,CAACqP,KAAMsC,EAAkBtC,OACpFrB,EAAKhO,mBAAmB0iB,GAAkBD,GAAc,CACtD1f,UAAWyf,EACX1J,KAAMyJ,EACNI,WAAYtB,EAAgBW,2BAEzB,CACL,IAEIY,EAFAC,GAAqE,IAAhD1e,EAAQW,EAAMrF,kBAAmB+iB,GACtDM,GAA0D,IAArC3e,EAAQW,EAAMjF,OAAQ2iB,GAG3CK,IACFD,EAAWP,EAAyBG,GACpCxU,EAAKvO,kBAAkBmjB,GAAY,CACjCvT,KAAMmT,EACN1J,KAAMyJ,EACNI,WAAYtB,EAAgBW,uBAE9BjB,EAAiB/S,EAAKvO,kBAAkBmjB,GAAWvB,EAAgB0B,aAAcP,IAE/EM,IACFF,EAAWR,EAAcI,GACzBxU,EAAKnO,OAAO+iB,GAAY,CACtBvT,KAAMmT,EACN1J,KAAMyJ,EACNI,WAAYtB,EAAgBW,uBAE9BjB,EAAiB/S,EAAKnO,OAAO+iB,GAAWvB,EAAgB0B,aAAcP,QAM5Erc,KAAKnG,mBAAqBqgB,EAAQla,KAAKnG,oBAGvC2E,EAAQlF,GAAmB,SAASujB,GAClC,IAAIC,EAAS5D,EAAQiD,GACjB3Q,EAAoB7M,EAAMmO,2BAA2B+P,GAGzDre,EAAQse,EAAOpjB,QAAQ,SAASqjB,EAAcC,GAC5C,IAAIP,EAEJ,GAAIjR,EAAmB,CACrBiR,EAAWtC,EAAUxb,EAAM9E,mBAAoB,CAACqP,KAAMsC,EAAkBtC,OACxE,IAAI+T,EAAiB9C,EAAUtS,EAAKhO,mBAAmB4iB,GAAW,CAAC7f,UAAWogB,IAG9E,IAAwB,IAApBC,EACF,OAGFpV,EAAKhO,mBAAmB4iB,GAAUQ,GAAgBtK,KAAO/R,EACvD,GACAiH,EAAKhO,mBAAmB4iB,GAAUQ,GAAgBtK,KAClDoK,OAEG,CACLN,EAAWP,EAAyBc,GAEpC,IAAIE,EAAsBhC,EAAgBxhB,QAAUwhB,EAAgBxhB,OAAOsjB,IAAW,GAEtFnV,EAAKvO,kBAAkBmjB,GAAY,CACjCvT,KAAM8T,EACNrK,KAAM7a,EAAS,GAAIilB,EAAcG,GACjCV,WAAYM,EAAOjB,uBAErBjB,EAAiB/S,EAAKvO,kBAAkBmjB,GAAWK,EAAOF,aAAcI,GAEpEre,EAAMtF,6BAA6B2jB,IACrCxe,EAAQG,EAAMtF,6BAA6B2jB,IAAS,SAASjf,IAEtD8J,EAAKvO,kBAAkBmjB,GAAU9J,KAAK5U,IACzCC,EAAQW,EAAMtF,6BAA6B2jB,GAASjf,IAAoB,IACxE8J,EAAKvO,kBAAkBmjB,GAAU9J,KAAK5U,GAAmB,UAMnEoe,OAIF3d,EAAQG,EAAMgP,gCAAgC,SAASwP,GACrD,IAAI3R,EAAoB7M,EAAMmO,2BAA2BqQ,GACrDvQ,EAAYjO,EAAMkO,+BAA+BrB,GAEjDxC,EAAoBrK,EAAMsK,0BAA0BkU,GAGxD,KAAiC,IAA7BnU,EAAkB7Q,QAAgB6Q,EAAkB,GAAG9Q,MAAM0U,GAAWzU,OAAS,GAArF,CAIA,IAAI2kB,EAAS5D,EAAQiD,GAErB3d,EAAQse,EAAOpjB,QAAQ,SAASqjB,EAAcC,GAC5C,IAAIP,EAAWtC,EAAUxb,EAAM9E,mBAAoB,CAACqP,KAAMsC,EAAkBtC,OACxE+T,EAAiB9C,EAAUtS,EAAKhO,mBAAmB4iB,GAAW,CAAC7f,UAAWogB,IAG9E,IAAwB,IAApBC,EAAJ,CAYA,IAAIG,EAAc,GAElB,GAAIpU,EAAkB7Q,OAAS,EAAG,CAChC,IAAIklB,EAAOrU,EAAkB,GAAG9Q,MAAM0U,GAAW,GACjDwQ,EAAYC,GAAQxV,EAAKhO,mBAAmB4iB,GAAUQ,GAAgBtK,KAAK0K,GAG7ExV,EAAKhO,mBAAmB4iB,GAAUQ,GAAgBtK,KAAO7a,EACvDslB,EACAL,EACAlV,EAAKhO,mBAAmB4iB,GAAUQ,GAAgBtK,UAItDwJ,QAIF3d,EAAQG,EAAMnF,gBAAgB,SAAS8jB,EAAU5S,GAC/C,IAAI+R,EAAWR,EAAcvR,GAE7B7C,EAAKnO,OAAO+iB,GAAY,CACtBvT,KAAMwB,EACNiI,KAAMuI,EAAgBxhB,OAAOgR,GAC7B8R,WAAYtB,EAAgBW,uBAE9Brd,EAAQ8e,GAAU,SAASzD,GACzBhS,EAAKnO,OAAO+iB,GAAY5U,EAAKnO,OAAO+iB,IAAa,CAACvT,KAAMwB,GACxD7C,EAAKnO,OAAO+iB,GAAU9J,KAAO9K,EAAKnO,OAAO+iB,GAAU9J,MAAQ,GAC3D9K,EAAKnO,OAAO+iB,GAAU9J,KAAKkH,GAAc,QAI7C7Z,KAAKnG,mBAAqB4E,EAAIuB,KAAKnG,mBAAoBof,EAAyBta,IAEhFqB,KAAKtG,OAASwgB,EAAQla,KAAKtG,QAC3BsG,KAAK1G,kBAAoB4gB,EAAQla,KAAK1G,mBAEtC0G,KAAKud,OAAS5e,EAwBhB,SAAS6e,EAA6BtE,EAAStc,GAC7C,IAAIvE,EAAY,CAAC6Q,KAAMtM,GACvB,GAAIsc,EAAQqE,OAAOre,mBAAmBtC,GAAY,CAChD,IAAIkM,EAAQrR,EAAKyhB,EAAQxf,OAAQrB,GACjC,OAAKyQ,EAEErK,EAAIqK,EAAM6J,MAAM,SAAStV,EAAG8K,GACjC,MAAO,CACLe,KAAMf,EACNgR,MAAO9b,EACPP,UAAWoc,EAAQqE,OAAOpe,eAAevC,EAAWuL,GACpDsV,WAAYvE,EAAQqE,OAAOlQ,iBAAiBzQ,EAAWuL,OAPxC,GAUd,GAAI+Q,EAAQqE,OAAOne,mBAAmBxC,GAAY,CACvD,IAAIigB,EAAmBplB,EAAKyhB,EAAQ5f,kBAAmBjB,GACvD,OAAKwkB,EAEEpe,EAAIoe,EAAiBlK,MAAM,SAAStV,EAAG8K,GAC5C,MAAO,CACLe,KAAMf,EACNgR,MAAO9b,EACPP,UAAWoc,EAAQqE,OAAOle,0BAA0BzC,EAAWuL,OANrC,GASzB,GAAI+Q,EAAQqE,OAAOje,oBAAoB1C,GAC5C,OAAOnF,EAAKyhB,EAAQrf,mBAAoBxB,GAS5C,SAASqlB,EAAQC,EAAQC,GACvB,IAAKA,EAAKjL,MAA6B,IAArBiL,EAAKjL,KAAKxa,OAC1B,OAAOylB,EAET,IAAIC,EAAWpf,EAAImf,EAAKjL,KAAM2H,EAAQoD,EAASC,IAC3CG,EAAiBH,EAAOE,GACxBE,EAAUnd,EAAM,GAAIgd,EAAM,CAACjL,KAAMmL,IACrC,OAAOC,EAKT,SAASC,EAAcC,EAAOtL,GAC5B,OAAOA,EAAKuF,KAAK+F,GA0FnB,SAASC,EAAyBpgB,EAAW4M,GAC3C,IAAIiI,EAAOlb,EAAKqG,EAAW,CAACoL,KAAMwB,IAClC,OAAOiI,GAAQA,EAAKoI,MA8DtB,SAASoD,EAAcxf,EAAOyf,EAAMC,EAAenV,EAAMoV,GACvD,IAAIxV,EAAQrR,EAAK6mB,EAAe,CAACpV,KAAMmV,IACnClF,EAAQvG,EAAI9J,EAAO,QAAUI,EAAO,KACpCsT,EAAa5J,EAAI9J,EAAO,cAC5B,MAAO,CACLsV,KAAMA,EACNC,cAAeA,EACfnV,KAAMA,EACNiQ,MAAOA,GAAS,EAChBqD,WAAYA,IAAc,GAI9B,SAASvT,EAA0BtK,EAAO0f,EAAenV,EAAMoV,GAK7D,IAJA,IAAIxV,EAAQrR,EAAK6mB,EAAe,CAACpV,KAAMmV,IACnCE,EAAmB5f,EAAMmO,2BAA2BuR,GACpDG,EAAWtV,EAAKhR,MAAMqmB,EAAiB3R,WACvC6R,EAAiBD,EAASA,EAASrmB,OAAS,GACvCgY,EAAI,OAAa7O,IAAVwH,GAAuBqH,EAAIqO,EAASrmB,SAAUgY,EAC5DrH,EAAQrR,EAAKqR,EAAM6J,KAAM,CAACzJ,KAAMsV,EAASrO,KAE3C,IAAIgJ,EAAQvG,EAAI9J,EAAO,SACnB0T,EAAa5J,EAAI9J,EAAO,cAC5B,MAAO,CACLsV,KAAM,eACNC,cAAeA,EACfnV,KAAMuV,EACNtF,MAAOA,GAAS,EAChBqD,WAAYA,IAAc,GArP9B5V,EAAcvG,UAAUqe,eAAiB,SAASxV,GAChD,IAAI7Q,EAAY,CAAC6Q,KAAMA,GAEvB,OAAOzR,EAAKuI,KAAKtG,OAAQrB,IACvBZ,EAAKuI,KAAK1G,kBAAmBjB,IAC7BZ,EAAKuI,KAAKnG,mBAAoBxB,IAuDlCuO,EAAc+X,aAAe,CAAC,iBAAkB,aAAc,YAmD9D/X,EAAcvG,UAAUue,eAAiB,SAAShiB,EAAWyF,GAC3D,IAAIwc,EAAcrB,EAA6Bxd,KAAMpD,GACrD,IAAKiiB,EAAa,MAAM,IAAIrhB,MAAMZ,EAAY,8BAE9C,IAAIoa,EAAUlf,EAAS,GAAIuK,EAAM,CAACxK,OAAQ+O,EAAc+X,eAExD,GAAI5d,MAAMuH,QAAQ0O,EAAQnf,QAAS,CACjC,IAAIomB,EAAQzD,EAAWxD,EAAQnf,OAAQ+O,EAAc+X,cACrD,OAAI5d,MAAMuH,QAAQuW,GACTtG,EAAQsG,EAAaZ,EAAM,GAAIA,EAAM,IAGvCP,EAAQnD,EAAahC,EAAS0F,EAAM,GAAIA,EAAM,IAAKY,GACrD,GAAIxiB,EAAW2a,EAAQnf,QAC5B,OAAIkJ,MAAMuH,QAAQuW,GACTA,EAAY3G,KAAKlB,EAAQnf,QAG3B6lB,EAAQpD,EAAQ0D,EAAehH,EAAQnf,QAASgnB,GAEzD,MAAM,IAAIrhB,MACR,sHAWJoJ,EAAcvG,UAAUye,cAAgB,SAASliB,GAC/C,GAAIoD,KAAKud,OAAOre,mBAAmBtC,GACjC,OAAOshB,EAAyBle,KAAKtG,OAAQkD,GACxC,GAAIoD,KAAKud,OAAOne,mBAAmBxC,GACxC,OAAOshB,EAAyBle,KAAK1G,kBAAmBsD,GAG1D,MAAM,IAAIY,MAAMZ,EAAY,uDAiB9BgK,EAAcvG,UAAU0e,eAAiB,WACvC,IAAIpgB,EAAQqB,KAAKud,OACbrE,EAAUlZ,KACVgf,EAAM,GA4CV,OA1CAxgB,EAAQG,EAAMlF,mBAAmB,SAAS6T,EAAa+Q,GACrD7f,EAAQ8O,GAAa,SAASpE,GAC5B8V,EAAI1mB,KAAK6lB,EAAcxf,EAAO,QAAS0f,EAAenV,EAAMgQ,EAAQxf,eAIxE8E,EAAQG,EAAMnF,gBAAgB,SAAS8T,EAAa+Q,GAClD7f,EAAQ8O,GAAa,SAASpE,GAC5B8V,EAAI1mB,KAAK6lB,EAAcxf,EAAO,UAAW0f,EAAenV,EAAMgQ,EAAQxf,eAI1E8E,EAAQG,EAAMtF,8BAA8B,SAASiU,EAAa+Q,GAChE7f,EAAQ8O,GAAa,SAASpE,GAC5B8V,EAAI1mB,KAAK6lB,EAAcxf,EAAO,cAAe0f,EAAenV,EAAMgQ,EAAQ5f,0BAI9EkF,EAAQG,EAAM/E,+BAA+B,SAAS0T,EAAa+Q,GACjE7f,EAAQ8O,GAAa,SAASpE,GAC5B8V,EAAI1mB,KAAK2Q,EAA0BtK,EAAO0f,EAAenV,EAAMgQ,EAAQrf,2BAI3E2E,EAAQG,EAAMhE,oBAAoB,SAAS6N,EAAW6V,GACpD7f,EAAQgK,GAAW,SAAS3K,EAAQ4K,GAClCjK,EAAQX,GAAQ,SAAShB,GACvBmiB,EAAI1mB,KAAK,CACP8lB,KAAM,UACNC,cAAeA,EACfnV,KAAMrM,EACNoiB,aAAcpiB,EACd4L,SAAUA,aAMlBjK,EAAQG,EAAMrD,gBAAgB,SAAS4N,GACrC8V,EAAI1mB,KAAK,CAAC8lB,KAAM,MAAOC,cAAe,QAASnV,KAAMA,OAGhD8V,GAmCTrnB,EAAOC,QAAUgP,G,kCC3wBjB,IAAIsY,EAAoB,EAAQ,QAC5BC,EAAsB,EAAQ,QAElCxnB,EAAOC,QAAUunB,EAAoBD,EAAmB,Y,qBCLxDvnB,EAAOC,QAAUsnB,EAEjB,IAAIpd,EAAS,EAAQ,QACjBsd,EAAc,EAAQ,QACtB3L,EAAY,EAAQ,QACpBlB,EAAQ,EAAQ,QAKhB8M,EAAqB,IACrBC,EACF,6CAAYA,sBAAwBC,SAAS,6CAAYD,qBAAsB,KAC/E,KA0BF,SAASJ,EAAkB/c,EAAeC,EAAQC,GAChD,IAAIQ,EAAQ,EAAQ,OAAR,CAAiB,iBAEzBgS,EAAQ,EAAQ,QAChBvM,EAAU,EAAQ,QAClB7J,EAAM,EAAQ,QAEdqW,EAAQ,oDAEZ,IAAoC,IAAhCzS,EAAKmd,yBAAoCrd,EAC3C,MAAM,IAAIL,EAAOqN,mBAAmB,qCAAuC2F,GAG7E,IAAoC,IAAhCzS,EAAKmd,yBAAoCpd,EAC3C,MAAM,IAAIN,EAAOqN,mBAAmB,8BAAgC2F,GAGtE9U,KAAKmC,cAAgBA,EACrBnC,KAAKoC,OAASA,EAEdpC,KAAKyf,MAAQ,CACXC,KAAM,GACNC,MAAO,IAGTtd,EAAOA,GAAQ,GAEfrC,KAAK4f,UAAYvd,EAAK4B,UAAY,CAChCC,QAAS,IACTwb,KAAM,IACNC,MAAO,KAILtd,EAAKwd,UACP7f,KAAK4f,UAAU1b,QAAUlE,KAAK4f,UAAUF,KAAO1f,KAAK4f,UAAUD,MAAQtd,EAAKwd,SAG7E,IAAIC,EAAWzd,EAAKyd,UAAY,SAOhC,GAJK,KAAKte,KAAKse,KACbA,GAAsB,KAGP,UAAbA,GAAqC,WAAbA,EAC1B,MAAM,IAAIhe,EAAOqN,mBAAmB,8CAAgD9M,EAAKyd,SAAW,MAKtG,GAFA9f,KAAK+f,kBAEA1d,EAAKod,MASCnX,EAAQjG,EAAKod,QAGtBzf,KAAKyf,MAAMC,KAAO7K,EAAMxS,EAAKod,OAC7Bzf,KAAKyf,MAAME,MAAQ9K,EAAMxS,EAAKod,SAE9Bzf,KAAKyf,MAAMC,KAAO7K,EAAMxS,EAAKod,MAAMC,MACnC1f,KAAKyf,MAAME,MAAQ9K,EAAMxS,EAAKod,MAAME,YAhBrB,CACf,IAAIK,EAAevhB,EAAIuB,KAAKigB,gBAAgB,SAASC,GACnD,OAAO/d,EAAgB,IAAM+d,EAAa,qBAIxCC,IAA2B,IAAb9d,EAAK+d,IAAgB,GAAK,QAAU,eACtDpgB,KAAKyf,MAAMC,KAAO,CAAC1f,KAAKmC,cAAgBge,GAAYljB,OAAO+iB,GAC3DhgB,KAAKyf,MAAME,MAAQ,CAAC3f,KAAKmC,cAAgB,gBAAgBlF,OAAO+iB,GAYlEhgB,KAAKyf,MAAMC,KAAOjhB,EAAIuB,KAAKyf,MAAMC,KAAMW,EAAYP,IACnD9f,KAAKyf,MAAME,MAAQlhB,EAAIuB,KAAKyf,MAAME,MAAOU,EAAYP,IAErD9f,KAAKsgB,aAAe,GAGpBtgB,KAAK8T,MAAQzR,EAAKke,QAAU,GAE5BvgB,KAAKuC,IAAMF,EAAKE,IAChBvC,KAAKwgB,iBAA+Blf,IAAnBe,EAAKme,YAA2Bne,EAAKke,SAAgBle,EAAKme,UAC3ExgB,KAAKygB,iBAAmBzgB,KAAKwgB,WAAane,EAAKoe,iBAC/CzgB,KAAK0gB,kBAAoCpf,IAArBe,EAAKse,aAAmCte,EAAKse,YAEjE3gB,KAAK+P,YAAc1N,EAAK0N,YAExBlN,EAAM,gBAAiB7C,MAswBzB,SAASqgB,EAAYP,GACnB,OAAO,SAAiBc,GACtB,OAAOd,EAAW,KAAOc,EAAKtiB,eAWlC,SAASuiB,EAAkBtf,GAGzB,QAA+BD,IAA3BP,MAAMV,UAAUygB,OAClB,OAAO5b,KAAKgK,UAAU3N,GAGxB,IAAIuf,EAAS/f,MAAMV,UAAUygB,cACtB/f,MAAMV,UAAUygB,OACvB,IAAI/oB,EAAMmN,KAAKgK,UAAU3N,GAGzB,OAFAR,MAAMV,UAAUygB,OAASA,EAElB/oB,EAGT,SAASgpB,EAAQxZ,GACf,IACIyZ,EACAC,EAFAC,EAAe3Z,EAAMpP,OAKzB,MAAwB,IAAjB+oB,EAELD,EAAc1Q,KAAK4Q,MAAM5Q,KAAK6Q,SAAWF,GACzCA,GAAgB,EAGhBF,EAAiBzZ,EAAM2Z,GACvB3Z,EAAM2Z,GAAgB3Z,EAAM0Z,GAC5B1Z,EAAM0Z,GAAeD,EAGvB,OAAOzZ,EAGT,SAAS8Z,EAAkB7d,GACzB,IAAI8d,EAAa,GAEjB,IAAK,IAAIC,KAAc/d,EAAS,CAE5B,IAAI3G,EADN,GAAI2kB,OAAOnhB,UAAUgB,eAAeJ,KAAKuC,EAAS+d,GAI9C1kB,EADiB,sBAAf0kB,GAAqD,6BAAfA,EAChC,mCAEA/d,EAAQ+d,GAGlBD,EAAWC,GAAc1kB,EAI7B,OAAOykB,EA9zBTpC,EAAkB7e,UAAUohB,UAAY,SAAS/N,GAC/C,OAAO,IAAID,EAAUzT,KAAM0T,IAS7BwL,EAAkB7e,UAAUqhB,eAAiB,SAASxY,EAAMrM,GAC1DmD,KAAKsgB,aAAapX,EAAK5K,eAAiBzB,GAQ1CqiB,EAAkB7e,UAAUshB,eAAiB,SAASzY,GACpD,OAAOlJ,KAAKsgB,aAAapX,EAAK5K,gBAQhC4gB,EAAkB7e,UAAUuhB,iBAAmB,SAAS1Y,UAC/ClJ,KAAKsgB,aAAapX,EAAK5K,gBAShC4gB,EAAkB7e,UAAUwhB,gBAAkB,SAASC,IACP,IAA1C9hB,KAAKuC,IAAIvE,QAAQ,IAAM8jB,KACzB9hB,KAAKuC,KAAO,IAAMuf,IAOtB5C,EAAkB7e,UAAUkU,aAAe,SAASwN,GAClD/hB,KAAK+f,kBAEL,IAGIpc,EACAqe,EAOAxe,EAXAye,EAAe,EAAQ,OAAR,CAAiB,iBAAmBF,EAAY1e,KAK/D8R,EAAe4M,EAAY5M,cAAgB,GAC3CrB,EAAQiO,EAAYjO,MACpBhN,EAAS9G,KACTkiB,EAAQ,EACRC,GAAgB,EAChBC,EAActb,EAAO4Z,cAAgB5Z,EAAO1D,SAAS6C,UAAY8b,EAAY9b,SAI/EjG,KAAKoC,OAAOjK,OAASknB,QACA/d,IAArBygB,EAAYpe,YACiBrC,IAA5BygB,EAAYpe,KAAKgE,aACYrG,IAA9BygB,EAAYpe,KAAK8R,WAEjBsM,EAAYpe,KAAKvB,OAASpC,KAAKoC,OAC/BoB,EAAUxD,KAAKqiB,uBAAuB,CACpClN,aAAcA,EACdmN,YAAY,EACZ9e,QAASue,EAAYve,WAGvBA,EAAUxD,KAAKqiB,uBAAuB,CACpClN,aAAcA,EACd3R,QAASue,EAAYve,eAIAlC,IAArBygB,EAAYpe,OACdA,EAAOkd,EAAkBkB,EAAYpe,OAGvCse,EAAa,iBACb,IAAIM,EAAY,GAGhB,SAASC,EAAUC,EAAWC,GAC5B5b,EAAOiZ,kBAEP,IAAI4C,EAAY,IAAI/R,KAapB,GAXI9J,EAAO0Z,YAAc1Z,EAAO2Z,mBAC9BuB,EAAUD,EAAY1e,KAKpByD,EAAO0Z,YAAc1Z,EAAO2Z,kBAAoB9c,IAClDqe,GAAW,SAAWU,EAAQ/e,MAI5Bif,GAA2B9b,EAAO2Z,iBAAkB3M,EAAOkO,GAAU,CACvEC,EAAa,+BAEb,IAAI7c,EAAe0O,EAAMkO,GAGzB,OAAOlb,EAAOV,SAAS9C,QAAQ,CAC7BK,KAAMuB,KAAKC,MAAMC,GACjBA,aAAcA,IAKlB,GAAI8c,GAASpb,EAAO2Y,MAAMsC,EAAYtN,UAAUtc,OAC9C,OAAKiqB,GAAeD,GAClBF,EAAa,8BAENnb,EAAOV,SAAS7C,OAAO,IAAIzB,EAAOqN,mBACvC,sIAE0BrI,EAAO3E,cAAe,CAACogB,UAAWA,OAIhEN,EAAa,yBAGbC,EAAQ,EAGRQ,EAAQ9d,OAASmd,EAAY9b,SAASrB,OACtC8d,EAAQrf,IAAM0e,EAAY9b,SAAS5C,IACnCqf,EAAQG,SAAWd,EAAY9b,SAAStC,KACpC+e,EAAQG,WACVH,EAAQ/e,KAAOkd,EAAkB6B,EAAQG,WAG3Crf,EAAUsD,EAAOub,uBAAuB,CACtClN,aAAcA,EACd3R,QAASue,EAAYve,UAGvBkf,EAAQze,SAAW6C,EAAOgc,uBAAuBf,EAAYtN,UAC7D3N,EAAOic,oBAAoB,EAAGhB,EAAYtN,UAC1C0N,GAAgB,EACTK,EAAU1b,EAAO1D,SAAS6C,SAAUyc,IAG7C,IAAIM,EAAclc,EAAOmc,eAAelB,EAAYtN,UAEhDpR,EAAM2f,EAAcN,EAAQrf,IAC5B2T,EAAU,CACZrT,KAAM+e,EAAQ/e,KACdkf,SAAUH,EAAQG,SAClBje,OAAQ8d,EAAQ9d,OAChBpB,QAASA,EACTS,SAAUye,EAAQze,SAClBpB,MAAOof,EACPpd,iBAAkB6d,EAAQ7d,kBAY5B,OATAod,EAAa,iDACXjL,EAAQpS,OAAQvB,EAAK2T,EAAQxT,QAASwT,EAAQ/S,UAE5Cwe,IAAc3b,EAAO1D,SAAS6C,UAChCgc,EAAa,kBAKRQ,EAAUxhB,KAAK6F,EAAQzD,EAAK2T,GAASkM,KAAKC,EAASC,GAE1D,SAASD,EAAQE,GASf,IAAI/d,EAAS+d,GAAgBA,EAAa1f,MAAQ0f,EAAa1f,KAAKyL,SAAWiU,EAAa1f,KAAK2B,QAK/F+d,EAAahe,YAKbge,GAAgBA,EAAa1f,MAAQ,IAEvCse,EAAa,0EACXoB,EAAahe,WAAYC,EAAQ+d,EAAa7f,SAEhD,IAAI8f,EAA8C,IAA7B/S,KAAK4Q,MAAM7b,EAAS,KAErCie,EAAU,IAAI3S,KAelB,GAdA2R,EAAUjqB,KAAK,CACb0qB,YAAaA,EACbxf,QAAS6d,EAAkB7d,GAC3B2C,QAASxC,GAAQ,KACjB6f,mBAAwBliB,IAATqC,EAAqBA,EAAKxL,OAAS,KAClDyM,OAAQ8d,EAAQ9d,OAChBX,SAAUye,EAAQze,SAClBZ,IAAKqf,EAAQrf,IACbsf,UAAWA,EACXY,QAASA,EACTE,SAAUF,EAAUZ,EACpBtd,WAAYC,IAGVge,EAKF,OAJIxc,EAAO0Z,YAAc1Z,EAAO2Z,kBAAoB3M,IAClDA,EAAMkO,GAAWqB,EAAaje,cAGzB,CACLA,aAAcie,EAAaje,aAC3BzB,KAAM0f,EAAa1f,MAIvB,IAAI+f,EAA2C,IAA7BnT,KAAK4Q,MAAM7b,EAAS,KAEtC,GAAIoe,EAEF,OADAxB,GAAS,EACFyB,IAGT1B,EAAa,uBAGb,IAAI2B,EAAqB,IAAI9hB,EAAOqN,mBAClCkU,EAAa1f,MAAQ0f,EAAa1f,KAAKyL,QAAS,CAACmT,UAAWA,EAAWld,WAAYC,IAGrF,OAAOwB,EAAOV,SAAS7C,OAAOqgB,GAGhC,SAASR,EAAYld,GAWnB+b,EAAa,uBAAwB/b,EAAIkJ,QAASlJ,EAAIqJ,OAEtD,IAAIgU,EAAU,IAAI3S,KAqBlB,OApBA2R,EAAUjqB,KAAK,CACb0qB,YAAaA,EACbxf,QAAS6d,EAAkB7d,GAC3B2C,QAASxC,GAAQ,KACjB6f,mBAAwBliB,IAATqC,EAAqBA,EAAKxL,OAAS,KAClDyM,OAAQ8d,EAAQ9d,OAChBX,SAAUye,EAAQze,SAClBZ,IAAKqf,EAAQrf,IACbsf,UAAWA,EACXY,QAASA,EACTE,SAAUF,EAAUZ,IAGhBzc,aAAepE,EAAOqN,qBAC1BjJ,EAAM,IAAIpE,EAAOgO,QAAQ5J,GAAOA,EAAIkJ,QAASlJ,IAG/Cgc,GAAS,EAMPhc,aAAepE,EAAOgO,SAGtB5J,aAAepE,EAAO2D,gBAGtByc,GAASpb,EAAO2Y,MAAMsC,EAAYtN,UAAUtc,SAC3CgqB,IAAkBC,IAEnBlc,EAAIqc,UAAYA,EACTzb,EAAOV,SAAS7C,OAAO2C,IAI5BA,aAAepE,EAAO+D,eACjBge,IAGFF,IAGT,SAASA,IAGP,OAFA1B,EAAa,oBACbnb,EAAOgd,oBAAoB/B,EAAYtN,UAChC+N,EAAUC,EAAWC,GAG9B,SAASmB,IAKP,OAJA5B,EAAa,wCACbnb,EAAOgd,oBAAoB/B,EAAYtN,UACvC3N,EAAOid,6BACPrB,EAAQze,SAAW6C,EAAOgc,uBAAuBf,EAAYtN,UACtD+N,EAAUC,EAAWC,IAIhC,SAASE,EACPoB,EACAC,EACAC,GAEA,OACEpd,EAAO0Z,WACPwD,GACAC,QACiC3iB,IAAjC2iB,EAAaC,GAKjB,SAASC,EAAsBzO,EAAStB,GAQtC,GAPIwO,EAA0B9b,EAAO2Z,iBAAkB3M,EAAOkO,IAC5DtM,EAAQ0O,OAAM,kBAELtQ,EAAMkO,MAImB,oBAAzBD,EAAY3N,SAarB,OAAOsB,EAAQwN,KAAK9O,GAXpBsB,EAAQwN,MAAK,SAAc/c,GACzBiZ,GAAY,WACV2C,EAAY3N,SAAS,KAAMA,EAASjO,MACnCW,EAAOiJ,aAAehM,eACxB,SAAgBmC,GACjBkZ,GAAY,WACV2C,EAAY3N,SAASlO,KACpBY,EAAOiJ,aAAehM,eAkB/B,GAVI+C,EAAO0Z,WAAa1Z,EAAO2Z,mBAC7BuB,EAAUD,EAAY1e,KAKpByD,EAAO0Z,WAAa1Z,EAAO2Z,kBAAoB9c,IACjDqe,GAAW,SAAWre,GAGpBif,EAA0B9b,EAAO2Z,iBAAkB3M,EAAOkO,GAAU,CACtEC,EAAa,8BAEb,IAAIoC,EAAuBvQ,EAAMkO,GAG7BsC,EAAuD,oBAA9BD,EAAqBnB,KAC9Cpc,EAAOV,SAAS9C,QAAQ,CAAC8B,aAAcif,IACvCA,EAEJ,OAAOF,EAAsBG,GAAiB,SAASne,GAErD,OAAOjB,KAAKC,MAAMgB,EAAQf,iBAI9B,IAAIsQ,EAAU8M,EACZ1b,EAAO1D,SAAU,CACfC,IAAK0e,EAAY1e,IACjBuB,OAAQmd,EAAYnd,OACpBjB,KAAMA,EACNkf,SAAUd,EAAYpe,KACtBM,SAAU6C,EAAOgc,uBAAuBf,EAAYtN,UACpD5P,iBAAkBkd,EAAYld,mBAQlC,OAJIiC,EAAO0Z,WAAa1Z,EAAO2Z,kBAAoB3M,IACjDA,EAAMkO,GAAWtM,GAGZyO,EAAsBzO,GAAS,SAASvP,GAE7C,OAAOA,EAAQxC,SAUnBub,EAAkB7e,UAAUiU,iBAAmB,SAAS5E,EAAM/H,GAC5D,QAAarG,IAAToO,GAA+B,OAATA,EACxB,OAAO/H,EAET,IAAK,IAAIzL,KAAOwT,EACF,OAARxT,QAA8BoF,IAAdoO,EAAKxT,IAAsBwT,EAAKrO,eAAenF,KACjEyL,GAAqB,KAAXA,EAAgB,GAAK,IAC/BA,GAAUzL,EAAM,IAAMsY,mBAAiE,mBAA9CgN,OAAOnhB,UAAU4O,SAAShO,KAAKyO,EAAKxT,IAA6B2kB,EAAkBnR,EAAKxT,IAAQwT,EAAKxT,KAGlJ,OAAOyL,GAUTuX,EAAkB7e,UAAUgiB,uBAAyB,SAASrL,GAC5D,IAAIxY,EAAU,EAAQ,QAElBgE,EAAKwU,EAAQ7B,aACfnV,KAAKuC,IAAM,IAAMyU,EAAQ7B,aACzBnV,KAAKuC,IAEHgiB,EAAiB,CACnB,kBAAmB/hB,EACnB,2BAA4BxC,KAAKmC,eA6BnC,OAtB2B,IAAvB6U,EAAQsL,aACViC,EAAe,qBAAuBvkB,KAAKoC,QAGzCpC,KAAKwkB,YACPD,EAAe,uBAAyBvkB,KAAKwkB,WAG3CxkB,KAAKykB,eACPF,EAAe,wBAA0BvkB,KAAKykB,cAGhDjmB,EAAQwB,KAAKsgB,cAAc,SAA6BzjB,EAAOX,GAC7DqoB,EAAeroB,GAAOW,KAGpBma,EAAQxT,SACVhF,EAAQwY,EAAQxT,SAAS,SAA6B3G,EAAOX,GAC3DqoB,EAAeroB,GAAOW,KAInB0nB,GAYTrF,EAAkB7e,UAAU2T,OAAS,SAAS0Q,EAASriB,EAAM+R,GAC3D,IAAI9L,EAAU,EAAQ,QAClB7J,EAAM,EAAQ,QAEdqW,EAAQ,mDAEZ,IAAKxM,EAAQoc,GACX,MAAM,IAAIlnB,MAAMsX,GAGE,oBAATzS,GACT+R,EAAW/R,EACXA,EAAO,SACWf,IAATe,IACTA,EAAO,IAGT,IAAIyE,EAAS9G,KAET2kB,EAAU,CACZlP,SAAUhX,EAAIimB,GAAS,SAAwB1pB,GAC7C,IAAI2M,EAAS,GASb,YAJoBrG,IAAhBtG,EAAMA,QACR2M,GAAU,SAAW6M,mBAAmBxZ,EAAMA,QAGzC,CACL0Y,UAAW1Y,EAAM0Y,UACjB/L,OAAQb,EAAOwN,iBAAiBtZ,EAAM2M,OAAQA,QAKhDid,EAAcnmB,EAAIkmB,EAAQlP,UAAU,SAA4BC,EAASmP,GAC3E,OAAOA,EAAY,IACjBrQ,mBACE,cAAgBA,mBAAmBkB,EAAQhC,WAAa,IACxDgC,EAAQ/N,WAEXgO,KAAK,KAEJtS,EAAM,uBAMV,YAJsB/B,IAAlBe,EAAKyiB,WACPH,EAAQG,SAAWziB,EAAKyiB,UAGnB9kB,KAAKuU,aAAa,CACvBT,MAAO9T,KAAK8T,MACZlP,OAAQ,OACRvB,IAAKA,EACLM,KAAMghB,EACNlQ,SAAU,OACVxO,SAAU,CACRrB,OAAQ,MACRvB,IAAK,eACLM,KAAM,CACJgE,OAAQid,IAGZxQ,SAAUA,KAmBd8K,EAAkB7e,UAAUuU,qBAAuB,SAAS8P,GAC1D,IAAIpc,EAAU,EAAQ,QAClB7J,EAAM,EAAQ,QAEdqW,EAAQ,4GAEZ,IAAKxM,EAAQoc,GACX,MAAM,IAAIlnB,MAAMsX,GAGlB,IAAIhO,EAAS9G,KAEb,OAAO8G,EAAOV,SAASI,IAAI/H,EAAIimB,GAAS,SAAsB1pB,GAC5D,IACGA,QACmBsG,IAApBtG,EAAM0Y,gBACqBpS,IAA3BtG,EAAM2M,OAAO+C,gBACepJ,IAA5BtG,EAAM2M,OAAOoN,WAEb,MAAM,IAAIvX,MAAMsX,GAGlB,IAAID,EAAQ,EAAQ,QAChBrY,EAAO,EAAQ,QAEfkX,EAAY1Y,EAAM0Y,UAClB/L,EAAS3M,EAAM2M,OAEf+C,EAAY/C,EAAO+C,UACnBsK,EAAiBxY,EAAKqY,EAAMlN,IAAS,SAASvG,GAChD,MAAmB,cAAZA,KAEL3B,EAAmBqH,EAAOwN,iBAAiBU,EAAgB,IAE/D,OAAOlO,EAAOyN,aAAa,CACzBT,MAAOhN,EAAOgN,MACdlP,OAAQ,OACRvB,IACE,cACAmR,mBAAmBd,GACnB,WACAc,mBAAmB9J,GACnB,SACF+J,SAAU,OACV9Q,KAAM,CAACgE,OAAQlI,UASrByf,EAAkB7e,UAAU0kB,gBAAkB,SAASC,GACrD,GAA6C,mBAAzCxD,OAAOnhB,UAAU4O,SAAShO,KAAK+jB,GAA4B,CAE7D,IADA,IAAIC,EAAU,GACL9U,EAAI,EAAGA,EAAI6U,EAAK7sB,SAAUgY,EACjC,GAAgD,mBAA5CqR,OAAOnhB,UAAU4O,SAAShO,KAAK+jB,EAAK7U,IAA0B,CAEhE,IADA,IAAI+U,EAAW,GACNC,EAAI,EAAGA,EAAIH,EAAK7U,GAAGhY,SAAUgtB,EACpCD,EAAS5sB,KAAK0sB,EAAK7U,GAAGgV,IAExBF,EAAQ3sB,KAAK,IAAM4sB,EAASvP,KAAK,KAAO,UAExCsP,EAAQ3sB,KAAK0sB,EAAK7U,IAGtB6U,EAAOC,EAAQtP,KAAK,KAGtB3V,KAAKykB,aAAeO,GAOtB9F,EAAkB7e,UAAU+kB,aAAe,SAASZ,GAClDxkB,KAAKwkB,UAAYA,GAOnBtF,EAAkB7e,UAAU0T,WAAa,WACvC/T,KAAK8T,MAAQ,IAQfoL,EAAkB7e,UAAUglB,kBAAoB,SAASC,GACnDA,IACFtlB,KAAK4f,UAAU1b,QAAUlE,KAAK4f,UAAUF,KAAO1f,KAAK4f,UAAUD,MAAQ2F,IAQ1EpG,EAAkB7e,UAAUklB,YAAc,SAASthB,GACjDjE,KAAK4f,UAAY3b,GAOnBib,EAAkB7e,UAAUmlB,YAAc,WACxC,OAAOxlB,KAAK4f,WAGdV,EAAkB7e,UAAUolB,cAAgB,WAC1C,IAAI9S,EAAOJ,EAAMK,IAAI5S,KAAKmC,eAE1B,OADa,OAATwQ,GAAe3S,KAAK0lB,gBAAgB/S,GACjCA,GAGTuM,EAAkB7e,UAAUslB,cAAgB,SAAShT,GAGnD,OAFAA,EAAKiT,YAAa,IAAKhV,MAAQiV,UAC/B7lB,KAAK0lB,gBAAgB/S,GACdJ,EAAMG,IAAI1S,KAAKmC,cAAewQ,IAGvCuM,EAAkB7e,UAAU0f,gBAAkB,WAC5C,IAAIpN,EAAO3S,KAAKylB,gBACZK,GAAM,IAAKlV,MAAQiV,UACvB,OAAa,OAATlT,GAAiBmT,EAAMnT,EAAKiT,WAAatG,EACpCtf,KAAK+lB,uBAAuBpT,GAG9BA,GAGTuM,EAAkB7e,UAAU0lB,uBAAyB,SAASpT,GAC5D,IAAIqT,EAAUrT,GAAQ,GAItB,OAHAqT,EAAQC,YAAc,CAACvG,KAAM,EAAGC,MAAO,GACvCqG,EAAQE,kBAAoB,EAC5BF,EAAQG,cAAgBH,EAAQG,eAAiBpF,EAAQ,CAAC,EAAG,EAAG,IACzD/gB,KAAK2lB,cAAcK,IAG5B9G,EAAkB7e,UAAUqlB,gBAAkB,SAAS/S,GACrD3S,KAAKomB,aAAezT,EAAKsT,YACzBjmB,KAAKqmB,mBAAqB1T,EAAKuT,kBAC/BlmB,KAAKigB,eAAiBtN,EAAKwT,eAG7BjH,EAAkB7e,UAAUimB,wBAA0B,SAASN,GAC7D,IAAIrlB,EAAU,EAAQ,QAClB4lB,EAAcvmB,KAAKylB,gBAKvB,OAJA9kB,EAAQqlB,GAAS,SAASnpB,EAAOX,GAC/BqqB,EAAYrqB,GAAOW,KAGdmD,KAAK2lB,cAAcY,IAG5BrH,EAAkB7e,UAAU4iB,eAAiB,SAASxO,GACpD,OAAOzU,KAAKyf,MAAMhL,GAAUzU,KAAKwmB,oBAAoB/R,KAGvDyK,EAAkB7e,UAAUomB,sBAAwB,WAClD,OAAOzmB,KAAKqmB,oBAGdnH,EAAkB7e,UAAUmmB,oBAAsB,SAAS/R,GACzD,OAAOzU,KAAKomB,aAAa3R,IAG3ByK,EAAkB7e,UAAU0iB,oBAAsB,SAAS2D,EAAWjS,GACpE,IAAII,EAAQ,EAAQ,QAChB8R,EAAiB9R,EAAM7U,KAAKomB,cAGhC,OAFAO,EAAelS,GAAYiS,EAC3B1mB,KAAKsmB,wBAAwB,CAACL,YAAaU,IACpCD,GAGTxH,EAAkB7e,UAAUyjB,oBAAsB,SAASrP,GACzD,OAAOzU,KAAK+iB,qBACT/iB,KAAKwmB,oBAAoB/R,GAAY,GAAKzU,KAAKyf,MAAMhL,GAAUtc,OAAQsc,IAI5EyK,EAAkB7e,UAAU0jB,2BAA6B,WACvD,IAAImC,EAAoB3V,KAAKqW,IAAI5mB,KAAKqmB,mBAAqB,EAAG,GAC9D,OAAOrmB,KAAKsmB,wBAAwB,CAACJ,kBAAmBA,KAG1DhH,EAAkB7e,UAAUyiB,uBAAyB,SAASrO,GAC5D,MAAO,CACLvQ,QAASlE,KAAK4f,UAAU1b,QAAUlE,KAAKqmB,mBACvCtgB,SAAU/F,KAAK4f,UAAUnL,GAAYzU,KAAKqmB,sB,kCC73B9C,IAAI7nB,EAAU,EAAQ,QAClBC,EAAM,EAAQ,QACdjH,EAAS,EAAQ,QACjBoJ,EAAQ,EAAQ,SAEhBimB,EAAiB,CAOnBC,YAAa,SAAoB5sB,EAAOyE,GACtC,IAAI+lB,EAAU,GAgCd,OA7BAA,EAAQpsB,KAAK,CACXob,UAAWxZ,EACXyN,OAAQkf,EAAeE,qBAAqBpoB,KAI9CH,EAAQG,EAAM8O,+BAA+B,SAAS0P,GACpDuH,EAAQpsB,KAAK,CACXob,UAAWxZ,EACXyN,OAAQkf,EAAeG,iCAAiCroB,EAAOwe,QAKnE3e,EAAQG,EAAMgP,gCAAgC,SAASwP,GACrD,IAAI3R,EAAoB7M,EAAMmO,2BAA2BqQ,GAErDnU,EAAoBrK,EAAMsK,0BAA0BkU,GAGpDvQ,EAAYjO,EAAMkO,+BAA+BrB,GACjDxC,EAAkB7Q,OAAS,GAAK6Q,EAAkB,GAAG9Q,MAAM0U,GAAWzU,OAAS,GACjFusB,EAAQpsB,KAAK,CACXob,UAAWxZ,EACXyN,OAAQkf,EAAeG,iCAAiCroB,EAAOwe,GAAc,QAK5EuH,GAQTqC,qBAAsB,SAASpoB,GAC7B,IAAIjF,EAASiF,EAAMjF,OAChBuD,OAAO0B,EAAMrF,mBACb2D,OAAO4pB,EAAeI,qCAAqCtoB,IAG1DuoB,EAAeL,EAAeM,iBAAiBxoB,GAC/CjE,EAAiBmsB,EAAeO,mBAAmBzoB,GACnDtD,EAAawrB,EAAeQ,eAAe1oB,GAC3C2oB,EAAmB,CACrB5tB,OAAQA,EACR2B,WAAYA,GAWd,OARI6rB,EAAa/uB,OAAS,IACxBmvB,EAAiBJ,aAAeA,GAG9BxsB,EAAevC,OAAS,IAC1BmvB,EAAiB5sB,eAAiBA,GAG7BkG,EAAMjC,EAAMoP,iBAAkBuZ,IAUvCN,iCAAkC,SAASroB,EAAOmK,EAAOye,GACvD,IAAIL,EAAeL,EAAeM,iBAAiBxoB,EAAOmK,EAAOye,GAC7D7sB,EAAiBmsB,EAAeO,mBAAmBzoB,EAAOmK,GAC1DzN,EAAawrB,EAAeQ,eAAe1oB,GAC3C2oB,EAAmB,CACrBttB,YAAa,EACbc,KAAM,EACN3B,qBAAsB,GACtBD,sBAAuB,GACvBE,oBAAqB,GACrBiC,WAAYA,EACZxC,WAAW,EACX2uB,gBAAgB,GAGdhc,EAAoB7M,EAAMmO,2BAA2BhE,GAoBzD,OAjBEwe,EAAiB5tB,OADf8R,EACwBqb,EAAeY,0CACvC9oB,EACA6M,EACA+b,GAGwBze,EAGxBpO,EAAevC,OAAS,IAC1BmvB,EAAiB5sB,eAAiBA,GAGhCwsB,EAAa/uB,OAAS,IACxBmvB,EAAiBJ,aAAeA,GAG3BtmB,EAAMjC,EAAMoP,iBAAkBuZ,IASvCF,mBAAoB,SAASzoB,EAAO+L,GAClC,GAAI/L,EAAMjE,eACR,OAAOiE,EAAMjE,eAGf,IAAIA,EAAiB,GAmBrB,OAjBA8D,EAAQG,EAAMhE,oBAAoB,SAAS6N,EAAW5L,GACpD4B,EAAQgK,GAAW,SAAS3K,EAAQ4K,GAC9BiC,IAAc9N,GAChB4B,EAAQX,GAAQ,SAAShB,GACvB,GAAIkE,MAAMuH,QAAQzL,GAAQ,CACxB,IAAI6qB,EAAKjpB,EAAI5B,GAAO,SAASQ,GAC3B,OAAOT,EAAY6L,EAAWpL,KAEhC3C,EAAepC,KAAKovB,QAEpBhtB,EAAepC,KAAKsE,EAAY6L,EAAW5L,YAO9CnC,GAQT2sB,eAAgB,SAAS1oB,GACvB,OAAIA,EAAMtD,WACDsD,EAAMtD,WAGRsD,EAAMrD,eAAeqa,KAAK,MAWnCwR,iBAAkB,SAASxoB,EAAOmK,EAAOye,GACvC,IAAIL,EAAe,GAmEnB,OAjEA1oB,EAAQG,EAAMlF,mBAAmB,SAASolB,EAAanU,GACrDlM,EAAQqgB,GAAa,SAAShF,GAC5BqN,EAAa5uB,KAAKoS,EAAY,IAAMmP,SAIxCrb,EAAQG,EAAMnF,gBAAgB,SAASqlB,EAAanU,GAClDlM,EAAQqgB,GAAa,SAAShF,GAC5BqN,EAAa5uB,KAAKoS,EAAY,KAAOmP,SAIzCrb,EAAQG,EAAMtF,8BAA8B,SAASwlB,EAAanU,GAChE,GAAIA,IAAc5B,GAAU+V,GAAsC,IAAvBA,EAAY1mB,OAAvD,CACA,IAAIwvB,EAAY,GAEhBnpB,EAAQqgB,GAAa,SAAShF,GAC5B8N,EAAUrvB,KAAKoS,EAAY,IAAMmP,MAGnCqN,EAAa5uB,KAAKqvB,OAGpBnpB,EAAQG,EAAM/E,+BAA+B,SAASilB,EAAanU,GACjE,IAAImP,EAAagF,EAAY,GAE7B,QAAmBvd,IAAfuY,EAAJ,CAIA,IAGI+N,EACAC,EAJArc,EAAoB7M,EAAMmO,2BAA2BpC,GACrDkC,EAAYjO,EAAMkO,+BAA+BrB,GACjDzC,EAAWpK,EAAMgQ,yBAAyBnD,GAK9C,GAAI1C,IAAU4B,EAAW,CAGvB,IAAuC,IAAnCmP,EAAW7b,QAAQ4O,KAAuB7D,IAAsC,IAA1Bwe,GACvDxe,GAAYA,EAAS7Q,MAAM0U,GAAWzU,SAAW0hB,EAAW3hB,MAAM0U,GAAWzU,OAC9E,OAGG4Q,GAIH8e,EAAkB9e,EAAS7Q,MAAM0U,GAAWzU,OAAS,EACrD0hB,EAAa9Q,IAJb8e,EAAkBhO,EAAW3hB,MAAM0U,GAAWzU,OAAS,EACvD0hB,EAAaA,EAAW7Y,MAAM,EAAG6Y,EAAW7M,YAAYJ,KAM1Dgb,EAAoBpc,EAAkBzM,WAAW8oB,QAEjDA,EAAkBhO,EAAW3hB,MAAM0U,GAAWzU,OAAS,EAEvDyvB,EAAoBpc,EAAkBzM,WAAW8oB,GAG/CD,GACFV,EAAa5uB,KAAK,CAACsvB,EAAoB,IAAM/N,QAI1CqN,GAGTD,qCAAsC,SAAStoB,GAC7C,IAAI5G,EAAM,GAEV,OAAOP,EACLmH,EAAM9E,oBAEN,SAA+CiuB,EAAetc,GAC5D,IAAIuc,EAAyBppB,EAAMsK,0BAA0BuC,EAAkBtC,MAAM,GAGrF,IAAK6e,EAEH,OADAD,EAAcxvB,KAAKkT,EAAkBzM,WAAW,IACzC+oB,EAGT,IAAIlb,EAAYjO,EAAMkO,+BAA+BrB,GACjD+N,EAAQwO,EAAuB7vB,MAAM0U,GAAWzU,OAChD6vB,EAAgBxc,EAAkBzM,WAAWiC,MAAM,EAAGuY,EAAQ,GAElE,OAAOuO,EAAc7qB,OAAO+qB,KAC3BjwB,IAGP0vB,0CAA2C,SAAS9oB,EAAO6M,EAAmByc,GAC5E,IAAIrb,EAAYjO,EAAMkO,+BAA+BrB,GACrD,IAAkB,IAAdyc,EAAoB,CACtB,IAAIlf,EAAWpK,EAAMgQ,yBAAyBnD,GAC1CyR,EAAiB,EAKrB,OAHIlU,IACFkU,EAAiBlU,EAAS7Q,MAAM0U,GAAWzU,QAEtC,CAACqT,EAAkBzM,WAAWke,IAGvC,IAAI8K,EAAyBppB,EAAMsK,0BAA0BuC,EAAkBtC,MAAM,IAAM,GAIvFgf,EAAcH,EAAuB7vB,MAAM0U,GAAWzU,OAAS,EACnE,OAAOqT,EAAkBzM,WAAWiC,MAAM,EAAGknB,EAAc,IAG7DC,uBAAwB,SAASzd,EAAW1P,EAAOotB,EAAczpB,GAC/D,IAAI0pB,EAA+B1pB,EAAMS,mBAAmBsL,GAC1D/L,EAAMwK,iBAAiBuB,GACvB/L,EACE2pB,EAAiC,CACnCvT,WAAY/Z,EACZ0P,UAAWA,GAEe,kBAAjB0d,IACTE,EAA+BF,aAAeA,GAEhD,IAAI1D,EAAU9jB,EAAMimB,EAAeE,qBAAqBsB,GAA+BC,GACvF,OAAO5D,IAIX/sB,EAAOC,QAAUivB,G,qBCrTjBlvB,EAAOC,QAAU2wB,EAEjB,IAAIC,EAAM,EAAQ,QACdlV,EAAoB,EAAQ,QAEhC,SAASiV,EAAmBrmB,GAC1B,OAAO,SAAgBumB,EAAOrmB,EAAQC,GACpC,IAAIC,EAAY,EAAQ,QAExBD,EAAOA,GAAQC,EAAUD,IAAS,GAClCA,EAAKod,MAAQpd,EAAKod,OAAS,CACzB,yBACA,0BACA,0BACA,2BAIuB,IAArBve,UAAU/I,QAAiC,kBAAVswB,QAAgCnnB,IAAVmnB,IACzDA,EAAQ,GACRrmB,EAAS,GACTC,EAAKmd,wBAAyB,GAGhC,IAAI1Y,EAAS5E,EAAcumB,EAAOrmB,EAAQC,GACtCnI,EAAQ4M,EAAO2a,UAAU,UAqB7B,OApBAvnB,EAAM8Z,OAASV,EAAkB,QAAS,mBAC1CpZ,EAAMwuB,QAAU,SAAS1R,EAAS5C,GAChC,IAAIuU,EAAUH,EAAIvsB,OAAO+a,GAEzB,OAAOhX,KAAK2T,GAAGY,aAAa,CAC1B3P,OAAQ,MACRvB,IAAK,qBAAuBslB,EAC5BlU,SAAU,OACVL,SAAUA,KAIdla,EAAMkb,UAAY,SAASC,EAAUjB,GACnC,OAAOpU,KAAK2T,GAAGY,aAAa,CAC1B3P,OAAQ,MACRvB,IAAK,aAAemR,mBAAmBa,GACvCZ,SAAU,OACVL,SAAUA,KAGPla,K,kCC5CXvC,EAAOC,QAAU,U,kCCAjB,IAAI+O,EAAmB,EAAQ,QAC3BC,EAAgB,EAAQ,QACxB/G,EAAgB,EAAQ,QACxBgnB,EAAiB,EAAQ,QAEzBlnB,EAAO,EAAQ,QACfC,EAAS,EAAQ,QAEjBgpB,EAAU,EAAQ,QAClBpqB,EAAU,EAAQ,QAClBlC,EAAU,EAAQ,QAClBmC,EAAM,EAAQ,QAEd4E,EAAM,EAAQ,QACdX,EAAU,EAAQ,QAwGtB,SAASgE,EAAoBI,EAAQ5M,EAAO8c,GACtClQ,EAAO+a,kBAAoBgH,EAA8B/hB,IAC3DA,EAAO+a,gBAAgB,aAAenf,GAGxC1C,KAAK8oB,UAAUhiB,GACf,IAAIzE,EAAO2U,GAAW,GACtB3U,EAAKnI,MAAQA,EACb8F,KAAKrB,MAAQgI,EAAiBiC,KAAKvG,GACnCrC,KAAKE,YAAc,KACnBF,KAAK+oB,SAAW,EAChB/oB,KAAKgpB,sBAAwB,EAC7BhpB,KAAKipB,eAAiB,GACtBjpB,KAAKkpB,kBAAoB,EAslB3B,SAASC,EAAeruB,GACtB,GAAIA,EAAO,EAAG,MAAM,IAAI0C,MAAM,2BAG9B,OADAwC,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQlP,IACzBkF,KAuST,SAASqpB,IACP,OAAOrpB,KAAKrB,MAAM7D,KAsXpB,SAAS+tB,EAA8B/hB,GAErC,IAAIwiB,EAAexiB,EAAOvE,IAC1B,QAAQ+mB,IACiC,IAAvCA,EAAatrB,QAAQ,aAzvCzB2B,EAAKQ,SAASuG,EAAqB9G,EAAOQ,cAa1CsG,EAAoBrG,UAAU2T,OAAS,WAErC,OADAhU,KAAKkV,UACElV,MAQT0G,EAAoBrG,UAAUkpB,SAAW,WACvC,IAAI5qB,EAAQqB,KAAKrB,MACjB,OAAOkoB,EAAeE,qBAAqBpoB,IAuC7C+H,EAAoBrG,UAAUmpB,WAAa,SAASxS,EAASyS,GAC3D,IAAIC,EAAa1S,EAAuBhX,KAAKrB,MAAMgL,mBAAmBqN,GAA3ChX,KAAKrB,MAC5B+lB,EAAUmC,EAAeC,YAAY4C,EAAUxvB,MAAOwvB,GACtD7hB,EAAO7H,KAMX,GAJAA,KAAKkpB,oBAELlpB,KAAK2pB,KAAK,aAAcD,IAEpBD,EAuBJ,OAAOzpB,KAAK8G,OAAOkN,OAAO0Q,GAASxB,MAAK,SAAS/c,GAG/C,OAFA0B,EAAKqhB,oBAC0B,IAA3BrhB,EAAKqhB,mBAAyBrhB,EAAK8hB,KAAK,oBACrC,CACLxjB,QAAS,IAAIS,EAAc8iB,EAAWvjB,EAAQ+S,SAC9Cva,MAAO+qB,EACPE,kBAAmBzjB,MAEpB,SAASX,GAGV,MAFAqC,EAAKqhB,oBAC0B,IAA3BrhB,EAAKqhB,mBAAyBrhB,EAAK8hB,KAAK,oBACtCnkB,KAjCNxF,KAAK8G,OACFkN,OAAO0Q,GACPxB,MAAK,SAAS/c,GACb0B,EAAKqhB,oBAC0B,IAA3BrhB,EAAKqhB,mBACPrhB,EAAK8hB,KAAK,oBAGZF,EAAG,KAAM,IAAI7iB,EAAc8iB,EAAWvjB,EAAQ+S,SAAUwQ,MAEzDtF,OAAM,SAASle,GACd2B,EAAKqhB,oBAC0B,IAA3BrhB,EAAKqhB,mBACPrhB,EAAK8hB,KAAK,oBAGZF,EAAGvjB,EAAK,KAAMwjB,OAuDtBhjB,EAAoBrG,UAAUuU,qBAAuB,SAAS9L,EAAO9N,EAAOotB,EAAcyB,GACxF,IAAIlrB,EAAQqB,KAAKrB,MAAMgL,mBAAmBkgB,GAAa,IACnDC,EAAgBnrB,EAAMS,mBAAmB0J,GACzCihB,EAAelD,EAAesB,uBAAuBrf,EAAO9N,EAAOotB,EAAczpB,GAErFqB,KAAKkpB,oBACL,IAAIrhB,EAAO7H,KAEXA,KAAK2pB,KAAK,uBAAwBhrB,EAAOmK,EAAO9N,GAChD,IAAIgvB,EAA0E,oBAArChqB,KAAK8G,OAAO8N,qBACjD5U,KAAK8G,OAAO8N,qBAAqB,CAAC,CAAClB,UAAW/U,EAAMzE,MAAOyN,OAAQoiB,KACnE/pB,KAAK8G,OAAO2a,UAAU9iB,EAAMzE,OAAO0a,qBAAqBmV,GAE5D,OAAOC,EAA4B9G,MAAK,SAAsB/c,GAY5D,OAXA0B,EAAKqhB,oBAC0B,IAA3BrhB,EAAKqhB,mBAAyBrhB,EAAK8hB,KAAK,oBAE5CxjB,EAAUpF,MAAMuH,QAAQnC,GAAWA,EAAQ,GAAKA,EAEhDA,EAAQ8jB,UAAYzrB,EAAQ2H,EAAQ8jB,WAAW,SAAS3sB,GACtDA,EAAER,UAAYgtB,EACZnrB,EAAMU,0BAA0ByJ,EAAOxL,EAAET,OACzC8B,EAAMQ,eAAe2J,EAAOxL,EAAET,UAG3BsJ,KACN,SAASX,GAGV,MAFAqC,EAAKqhB,oBAC0B,IAA3BrhB,EAAKqhB,mBAAyBrhB,EAAK8hB,KAAK,oBACtCnkB,MAaVkB,EAAoBrG,UAAUyJ,SAAW,SAASogB,GAEhD,OADAlqB,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGF,SAASogB,IACrClqB,MA0BT0G,EAAoBrG,UAAU8I,iBAAmB,SAASD,GAExD,OADAlJ,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGb,iBAAiBD,IAC7ClJ,MAWT0G,EAAoBrG,UAAUuJ,UAAY,WAExC,OADA5J,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGJ,aAC5B5J,MAcT0G,EAAoBrG,UAAUsL,8BAAgC,SAAS7C,EAAOjM,GAE5E,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAG2B,8BAA8B7C,EAAOjM,IACjEmD,MAMT0G,EAAoBrG,UAAU8pB,qBAAuB,WACnD,OAAOnqB,KAAK2L,8BAA8B1I,MAAMjD,KAAMkB,YAgBxDwF,EAAoBrG,UAAU4M,+BAAiC,SAASnE,EAAOjM,GAE7E,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGiD,+BAA+BnE,EAAOjM,IAClEmD,MAeT0G,EAAoBrG,UAAUkK,qBAAuB,SAAS3N,EAAW6L,EAAU5L,GAEjF,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGO,qBAAqB3N,EAAW6L,EAAU5L,IACtEmD,MAcT0G,EAAoBrG,UAAUoL,mBAAqB,SAAS3C,EAAOjM,GAEjE,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGyB,mBAAmB3C,EAAOjM,IACtDmD,MAMT0G,EAAoBrG,UAAU+pB,UAAY,WACxC,OAAOpqB,KAAKyL,mBAAmBxI,MAAMjD,KAAMkB,YAe7CwF,EAAoBrG,UAAUgqB,kBAAoB,SAASvhB,EAAOjM,GAEhE,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAG0B,qBAAqB5C,EAAOjM,IACxDmD,MAMT0G,EAAoBrG,UAAUiqB,WAAa,WACzC,OAAOtqB,KAAKqqB,kBAAkBpnB,MAAMjD,KAAMkB,YAa5CwF,EAAoBrG,UAAUkqB,OAAS,SAAS1e,GAE9C,OADA7L,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAG4B,iBAAiBC,IAC7C7L,MAqBT0G,EAAoBrG,UAAUwK,wBAA0B,SAASjO,EAAW6L,EAAU5L,GAEpF,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGa,wBAAwBjO,EAAW6L,EAAU5L,IACzEmD,MAiBT0G,EAAoBrG,UAAUgM,iCAAmC,SAASvD,EAAOjM,GAE/E,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGqC,iCAAiCvD,EAAOjM,IACpEmD,MAMT0G,EAAoBrG,UAAUmqB,wBAA0B,WACtD,OAAOxqB,KAAKqM,iCAAiCpJ,MAAMjD,KAAMkB,YAW3DwF,EAAoBrG,UAAU8M,kCAAoC,SAASrE,GAGzE,OAFA9I,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGmD,kCAAkCrE,IAE9D9I,MAiBT0G,EAAoBrG,UAAU8L,sBAAwB,SAASrD,EAAOjM,GAEpE,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGmC,sBAAsBrD,EAAOjM,IACzDmD,MAMT0G,EAAoBrG,UAAUoqB,aAAe,WAC3C,OAAOzqB,KAAKmM,sBAAsBlJ,MAAMjD,KAAMkB,YAiBhDwF,EAAoBrG,UAAUqqB,qBAAuB,SAAS5hB,EAAOjM,GAEnE,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGoC,wBAAwBtD,EAAOjM,IAC3DmD,MAMT0G,EAAoBrG,UAAUsqB,cAAgB,WAC5C,OAAO3qB,KAAK0qB,qBAAqBznB,MAAMjD,KAAMkB,YAa/CwF,EAAoBrG,UAAUuqB,UAAY,SAAS/e,GAEjD,OADA7L,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGsC,oBAAoBT,IAChD7L,MAcT0G,EAAoBrG,UAAUwqB,qBAAuB,SAAS/hB,EAAOjM,GAEnE,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAG2C,6BAA6B7D,EAAOjM,IAChEmD,MAMT0G,EAAoBrG,UAAUyqB,cAAgB,WAC5C,OAAO9qB,KAAK6qB,qBAAqB5nB,MAAMjD,KAAMkB,YAkB/CwF,EAAoBrG,UAAU9C,iBAAmB,SAASuL,EAAOjM,GAC/D,OAAOmD,KAAKwM,sBAAsB1D,EAAOjM,IAiB3C6J,EAAoBrG,UAAUmM,sBAAwB,SAAS1D,EAAOjM,GAEpE,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGwC,sBAAsB1D,EAAOjM,IACzDmD,MAMT0G,EAAoBrG,UAAU0qB,aAAe,WAC3C,OAAO/qB,KAAKwM,sBAAsBvJ,MAAMjD,KAAMkB,YAahDwF,EAAoBrG,UAAU2qB,UAAY,SAASnf,GAEjD,OADA7L,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGoD,oBAAoBvB,IAChD7L,MAYT0G,EAAoBrG,UAAU4qB,SAAW,WACvC,OAAOjrB,KAAKgK,QAAQhK,KAAKrB,MAAM7D,KAAO,IAYxC4L,EAAoBrG,UAAU6qB,aAAe,WAC3C,OAAOlrB,KAAKgK,QAAQhK,KAAKrB,MAAM7D,KAAO,IAqBxC4L,EAAoBrG,UAAU8oB,eAAiBA,EAU/CziB,EAAoBrG,UAAU2J,QAAUmf,EAWxCziB,EAAoBrG,UAAUwJ,SAAW,SAASX,GAEhD,OADAlJ,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGH,SAASX,IACrClJ,MAoBT0G,EAAoBrG,UAAU6N,kBAAoB,SAASC,EAAWtR,GAEpE,OADAmD,KAAKopB,QAAQppB,KAAKrB,MAAMqL,QAAQ,GAAGkE,kBAAkBC,EAAWtR,IACzDmD,MAUT0G,EAAoBrG,UAAU8qB,SAAW,SAAS1c,GAEhD,OADAzO,KAAKopB,QAAQziB,EAAiBiC,KAAK6F,IAC5BzO,MAgBT0G,EAAoBrG,UAAU+qB,SAAW,SAASxsB,GAChD,YAAgB0C,IAAZ1C,EAA8BoB,KAAKrB,MAChCqB,KAAKrB,MAAMpC,OAAOqC,IAmB3B8H,EAAoBrG,UAAUgrB,sBAAwB,SAA+BrU,GACnF,IAAIpY,EAAUoY,GAAWA,EAAQpY,SAAW,CAAC,QAAS,eAClDC,EAAemB,KAAKorB,SAASxsB,GAEjC,OAAOyE,EAAIuU,wBAAwB/Y,EAAcmY,IAgBnDtQ,EAAoB4kB,gCAAkCjoB,EAAIyT,wBAa1DpQ,EAAoB6kB,qCAAuCloB,EAAIoU,uCAW/D/Q,EAAoBrG,UAAUmrB,wBAA0B,SAASzU,EAAaC,GAC5E,IAAIyU,EAAgBzU,GAAWA,EAAQyU,gBAAiB,EACpDC,EAAgBroB,EAAIyT,wBAAwBC,EAAaC,GACzD2U,EAAe3rB,KAAKrB,MAAMgL,mBAAmB+hB,GAE7CD,EAAezrB,KAAKmrB,SAASQ,GAC5B3rB,KAAK4rB,0CAA0CD,IAoBtDjlB,EAAoBrG,UAAUurB,0CAA4C,SAASnd,GAEjF,OADAzO,KAAKrB,MAAQ,IAAIgI,EAAiB8H,GAC3BzO,MAMT0G,EAAoBrG,UAAUvD,UAAY,SAASgM,EAAOjM,GACxD,GAAImD,KAAKrB,MAAMO,mBAAmB4J,GAChC,OAAO9I,KAAKrB,MAAMQ,eAAe2J,EAAOjM,GACnC,GAAImD,KAAKrB,MAAMS,mBAAmB0J,GACvC,OAAO9I,KAAKrB,MAAMU,0BAA0ByJ,EAAOjM,GAGrD,MAAM,IAAIW,MAAMsL,sHA4BlBpC,EAAoBrG,UAAUwrB,eAAiB,SAASjvB,GACtD,OAAKN,EAAQ0D,KAAKrB,MAAMa,sBAAsB5C,MAEnCoD,KAAKrB,MAAMO,mBAAmBtC,GAChCoD,KAAKrB,MAAMQ,eAAevC,GACxBoD,KAAKrB,MAAMS,mBAAmBxC,GAChCoD,KAAKrB,MAAMU,0BAA0BzC,KACnCoD,KAAKrB,MAAMW,oBAAoB1C,IACjCoD,KAAKrB,MAAMY,2BAA2B3C,KA8BjD8J,EAAoBrG,UAAUod,WAAa,SAAS3U,EAAOjM,GACzD,OAAOmD,KAAKrB,MAAM0O,iBAAiBvE,EAAOjM,IAM5C6J,EAAoBrG,UAAUyrB,qBAAuB,SAAShjB,EAAOjM,GACnE,OAAOmD,KAAKrB,MAAMU,0BAA0ByJ,EAAOjM,IAQrD6J,EAAoBrG,UAAU0rB,OAAS,SAASlgB,GAC9C,OAAO7L,KAAKrB,MAAMmN,aAAaD,IAMjCnF,EAAoBrG,UAAUyL,aAAe,WAC3C,OAAO9L,KAAKgsB,kBAAkB/oB,MAAMjD,KAAMkB,YAW5CwF,EAAoBrG,UAAU4rB,SAAW,WACvC,OAAOjsB,KAAKrB,MAAMzE,OAYpBwM,EAAoBrG,UAAUgpB,eAAiBA,EAM/C3iB,EAAoBrG,UAAU6rB,QAAU7C,EAOxC3iB,EAAoBrG,UAAU8rB,QAAU,WACtC,OAAOnsB,KAAKrB,MAAMrD,gBAiBpBoL,EAAoBrG,UAAU4N,kBAAoB,SAASme,GACzD,OAAOpsB,KAAKrB,MAAMsP,kBAAkBme,IA+CtC1lB,EAAoBrG,UAAU0e,eAAiB,SAASrU,GACtD,IAAI4C,EAAc,GAElB,GAAItN,KAAKrB,MAAMO,mBAAmBwL,GAAY,CAC5C,IAAI2hB,EAAkBrsB,KAAKrB,MAAM8L,0BAA0BC,GAE3DlM,EAAQ6tB,GAAiB,SAASC,GAChChf,EAAYhV,KAAK,CACfuE,MAAOyvB,EACPlO,KAAM,mBAIV,IAAImO,EAAqBvsB,KAAKrB,MAAMiM,sBAAsBF,GAE1DlM,EAAQ+tB,GAAoB,SAASD,GACnChf,EAAYhV,KAAK,CACfuE,MAAOyvB,EACPlO,KAAM,oBAGL,GAAIpe,KAAKrB,MAAMS,mBAAmBsL,GAAY,CACnD,IAAI8hB,EAAkBxsB,KAAKrB,MAAMgM,0BAA0BD,GAE3DlM,EAAQguB,GAAiB,SAASF,GAChChf,EAAYhV,KAAK,CACfuE,MAAOyvB,EACPlO,KAAM,mBAKZ,IAAIzjB,EAAqBqF,KAAKrB,MAAMa,sBAAsBkL,GAU1D,OARAlM,EAAQ7D,GAAoB,SAASkC,EAAO4L,GAC1C6E,EAAYhV,KAAK,CACfuE,MAAOA,EACP4L,SAAUA,EACV2V,KAAM,eAIH9Q,GAST5G,EAAoBrG,UAAU2K,qBAAuB,SAASpO,EAAW6L,GACvE,OAAOzI,KAAKrB,MAAMqM,qBAAqBpO,EAAW6L,IAQpD/B,EAAoBrG,UAAU0O,+BAAiC,SAASrE,GACtE,OAAO1K,KAAKrB,MAAMoQ,+BAA+BrE,IAanDhE,EAAoBrG,UAAU6U,QAAU,WACtC,IAAIvW,EAAQqB,KAAKrB,MACb8tB,EAAc5F,EAAeC,YAAYnoB,EAAMzE,MAAOyE,GAEtD+tB,EAAS,CAAC,CACZ/tB,MAAOA,EACPguB,aAAcF,EAAYt0B,OAC1By0B,OAAQ5sB,OAGVA,KAAK2pB,KAAK,SAAUhrB,EAAOqB,KAAKE,aAEhC,IAAI2sB,EAAiBpuB,EAAIuB,KAAKipB,gBAAgB,SAAS6D,GACrD,IAAIC,EAAeD,EAAcrsB,iBAAiB9B,GAC9C+lB,EAAUmC,EAAeC,YAAYiG,EAAa7yB,MAAO6yB,GAO7D,OANAL,EAAOp0B,KAAK,CACVqG,MAAOouB,EACPJ,aAAcjI,EAAQvsB,OACtBy0B,OAAQE,IAEVA,EAAcnD,KAAK,SAAUoD,EAAcD,EAAc5sB,aAClDwkB,KAGLA,EAAU+H,EAAYxvB,OAAO2rB,EAAQiE,IACrCG,EAAUhtB,KAAK+oB,WAEnB/oB,KAAKkpB,oBAEL,IACElpB,KAAK8G,OAAOkN,OAAO0Q,GAChBxB,KAAKljB,KAAKitB,yBAAyBxb,KAAKzR,KAAM0sB,EAAQM,IACtD5I,MAAMpkB,KAAKktB,sBAAsBzb,KAAKzR,KAAMgtB,IAC/C,MAAO9mB,GAEPlG,KAAK2pB,KAAK,QAASzjB,KAevBQ,EAAoBrG,UAAU4sB,yBAA2B,SAASP,EAAQM,EAAS7mB,GAGjF,KAAI6mB,EAAUhtB,KAAKgpB,sBAAnB,CAKAhpB,KAAKkpB,mBAAsB8D,EAAUhtB,KAAKgpB,qBAC1ChpB,KAAKgpB,qBAAuBgE,EAEG,IAA3BhtB,KAAKkpB,mBAAyBlpB,KAAK2pB,KAAK,oBAE5C,IAAIzQ,EAAU/S,EAAQ+S,QAAQlY,QAC9BxC,EAAQkuB,GAAQ,SAASS,GACvB,IAAIxuB,EAAQwuB,EAAExuB,MACVguB,EAAeQ,EAAER,aACjBC,EAASO,EAAEP,OACXQ,EAAkBlU,EAAQ9H,OAAO,EAAGub,GAEpCU,EAAoBT,EAAO1sB,YAAc,IAAI0G,EAAcjI,EAAOyuB,GACtER,EAAOjD,KAAK,SAAU0D,EAAmB1uB,QAI7C+H,EAAoBrG,UAAU6sB,sBAAwB,SAASF,EAAS9mB,GAClE8mB,EAAUhtB,KAAKgpB,uBAKnBhpB,KAAKkpB,mBAAqB8D,EAAUhtB,KAAKgpB,qBACzChpB,KAAKgpB,qBAAuBgE,EAE5BhtB,KAAK2pB,KAAK,QAASzjB,GAEY,IAA3BlG,KAAKkpB,mBAAyBlpB,KAAK2pB,KAAK,sBAG9CjjB,EAAoBrG,UAAUitB,mBAAqB,SAAStyB,EAAOksB,EAAcxsB,EAAgBW,GAC/F,OAAOL,GACmB,IAAxBksB,EAAa/uB,QACa,IAA1BuC,EAAevC,QACO,IAAtBkD,EAAWlD,QASfuO,EAAoBrG,UAAUktB,2BAA6B,SAASzkB,GAClE,OAAO9I,KAAKrB,MAAM6uB,uBAAuB1kB,IACvC9I,KAAKrB,MAAM6uB,uBAAuB1kB,GAAO3Q,OAAS,GAGtDuO,EAAoBrG,UAAU+oB,QAAU,SAAS3a,GAC3CA,IAAazO,KAAKrB,QACpBqB,KAAKrB,MAAQ8P,EACbzO,KAAK2pB,KAAK,SAAU3pB,KAAKrB,MAAOqB,KAAKE,eAQzCwG,EAAoBrG,UAAU0T,WAAa,WAEzC,OADA/T,KAAK8G,OAAOiN,YAAc/T,KAAK8G,OAAOiN,aAC/B/T,MAST0G,EAAoBrG,UAAUyoB,UAAY,SAAS2E,GACjD,OAAIztB,KAAK8G,SAAW2mB,IAEhBA,EAAU5L,kBAAoBgH,EAA8B4E,IAAYA,EAAU5L,gBAAgB,aAAenf,GACrH1C,KAAK8G,OAAS2mB,GAHwBztB,MAYxC0G,EAAoBrG,UAAUqtB,UAAY,WACxC,OAAO1tB,KAAK8G,QAsBdJ,EAAoBrG,UAAUstB,OAAS,SAAS5tB,GAC9C,IAAI+sB,EAAgB,IAAIjtB,EAAcG,KAAMD,GAE5C,OADAC,KAAKipB,eAAe3wB,KAAKw0B,GAClBA,GAUTpmB,EAAoBrG,UAAUG,oBAAsB,SAASssB,GAC3D,IAAIc,EAAM5tB,KAAKipB,eAAejrB,QAAQ8uB,GACtC,IAAa,IAATc,EAAY,MAAM,IAAIpwB,MAAM,mCAChCwC,KAAKipB,eAAe7X,OAAOwc,EAAK,IAOlClnB,EAAoBrG,UAAUwtB,mBAAqB,WACjD,OAAO7tB,KAAKkpB,kBAAoB,GA+BlCvxB,EAAOC,QAAU8O,G,qBCp4CjB,IAAI/F,EAAU,EAAQ,QAEtBhJ,EAAOC,QAAU,SAAak2B,EAAK/tB,GACjC,IAAIguB,EAAS,GAIb,OAHAptB,EAAQmtB,GAAK,SAASE,EAAMC,GAC1BF,EAAOz1B,KAAKyH,EAAGiuB,EAAMC,EAAWH,OAE3BC,I,sBCPT,YAsCA,SAASrc,IAIP,QAAsB,qBAAXwc,SAA0BA,OAAOC,SAAmC,aAAxBD,OAAOC,QAAQ/P,QAM1C,qBAAbgQ,UAA4BA,SAASC,iBAAmBD,SAASC,gBAAgBC,OAASF,SAASC,gBAAgBC,MAAMC,kBAEnH,qBAAXL,QAA0BA,OAAO1c,UAAY0c,OAAO1c,QAAQgd,SAAYN,OAAO1c,QAAQid,WAAaP,OAAO1c,QAAQkd,QAGrG,qBAAdC,WAA6BA,UAAUC,WAAaD,UAAUC,UAAUtwB,cAAc0S,MAAM,mBAAqBuO,SAASpN,OAAO0c,GAAI,KAAO,IAE9H,qBAAdF,WAA6BA,UAAUC,WAAaD,UAAUC,UAAUtwB,cAAc0S,MAAM,uBAsBxG,SAASK,EAAW3B,GAClB,IAAIgC,EAAY1R,KAAK0R,UASrB,GAPAhC,EAAK,IAAMgC,EAAY,KAAO,IAC1B1R,KAAKkQ,WACJwB,EAAY,MAAQ,KACrBhC,EAAK,IACJgC,EAAY,MAAQ,KACrB,IAAM9Z,EAAQ0a,SAAStS,KAAK6Q,MAE3Ba,EAAL,CAEA,IAAIod,EAAI,UAAY9uB,KAAK2R,MACzBjC,EAAK0B,OAAO,EAAG,EAAG0d,EAAG,kBAKrB,IAAI50B,EAAQ,EACR60B,EAAQ,EACZrf,EAAK,GAAGnR,QAAQ,eAAe,SAASyS,GAClC,OAASA,IACb9W,IACI,OAAS8W,IAGX+d,EAAQ70B,OAIZwV,EAAK0B,OAAO2d,EAAO,EAAGD,IAUxB,SAASvd,IAGP,MAAO,kBAAoBC,SACtBA,QAAQD,KACRyd,SAAS3uB,UAAU4C,MAAMhC,KAAKuQ,QAAQD,IAAKC,QAAStQ,WAU3D,SAAS6Q,EAAKD,GACZ,IACM,MAAQA,EACVla,EAAQq3B,QAAQ5b,WAAW,SAE3Bzb,EAAQq3B,QAAQpsB,MAAQiP,EAE1B,MAAMtM,KAUV,SAAS0pB,IACP,IAAI5C,EACJ,IACEA,EAAI10B,EAAQq3B,QAAQpsB,MACpB,MAAM2C,IAOR,OAJK8mB,GAAwB,qBAAZ6B,GAA2B,QAASA,IACnD7B,EAAI,6CAAY6C,OAGX7C,EAoBT,SAAS8C,IACP,IACE,OAAOlB,OAAOpb,aACd,MAAOtN,KAjLX5N,EAAUD,EAAOC,QAAU,EAAQ,QACnCA,EAAQ2Z,IAAMA,EACd3Z,EAAQyZ,WAAaA,EACrBzZ,EAAQma,KAAOA,EACfna,EAAQs3B,KAAOA,EACft3B,EAAQ8Z,UAAYA,EACpB9Z,EAAQq3B,QAAU,oBAAsBI,QACtB,oBAAsBA,OAAOJ,QAC3BI,OAAOJ,QAAQK,MACfF,IAMpBx3B,EAAQ0Y,OAAS,CACf,gBACA,cACA,YACA,aACA,aACA,WAmCF1Y,EAAQuZ,WAAWgU,EAAI,SAAS9nB,GAC9B,IACE,OAAO6H,KAAKgK,UAAU7R,GACtB,MAAO6I,GACP,MAAO,+BAAiCA,EAAIkJ,UAqGhDxX,EAAQia,OAAOqd,O,2CCvKfv3B,EAAOC,QAAU0b,EAEjB,IAAIxR,EAAS,EAAQ,QAQrB,SAASwR,EAAkBic,EAAYlsB,GAQrC,OAAO,SAAgBrI,EAAO0U,EAAM0E,GAElC,GAAqB,oBAAVpZ,GAAwC,kBAAT0U,GACpB,kBAAb0E,EAGP,MAAM,IAAItS,EAAOqN,mBAAmB,yDAIb,IAArBjO,UAAU/I,QAAiC,oBAAV6C,GAEnCoZ,EAAWpZ,EACXA,EAAQ,IACsB,IAArBkG,UAAU/I,QAAgC,oBAATuX,IAE1C0E,EAAW1E,EACXA,OAAOpO,GAKY,kBAAVtG,GAAgC,OAAVA,GAC/B0U,EAAO1U,EACPA,OAAQsG,QACWA,IAAVtG,GAAiC,OAAVA,IAChCA,EAAQ,IAGV,IAMIma,EANAxN,EAAS,GAiBb,YAfcrG,IAAVtG,IACF2M,GAAU4nB,EAAa,IAAM/a,mBAAmBxZ,SAIrCsG,IAAToO,IACEA,EAAKyF,eACPA,EAAezF,EAAKyF,oBACbzF,EAAKyF,cAGdxN,EAAS3H,KAAK2T,GAAGW,iBAAiB5E,EAAM/H,IAInC3H,KAAKkV,QAAQvN,EAAQtE,EAAK+Q,EAAUe,M,kCC9D/Cxd,EAAOC,QAAUoK,EAEjB,IAAIF,EAAS,EAAQ,QAEjB0tB,EAAe,EAEnB,SAASxtB,EAAaqB,EAAKhB,EAAMonB,GAC/B,GAAoB,QAAhBpnB,EAAKuC,OAAT,CAKAvC,EAAKQ,MAAM,gBAEX,IAAI4sB,GAAW,EACX/rB,GAAW,EAEf8rB,GAAgB,EAChB,IAAIE,EAAOtB,SAASuB,qBAAqB,QAAQ,GAC7CC,EAASxB,SAASyB,cAAc,UAChCC,EAAS,gBAAkBN,EAC3BO,GAAO,EAEX7B,OAAO4B,GAAU,SAASnd,GACxBqd,IAEItsB,EACFrB,EAAKQ,MAAM,iCAIb4sB,GAAW,EAEXQ,IAEAxG,EAAG,KAAM,CACP9lB,KAAMgP,EACNvN,aAAcF,KAAKgK,UAAUyD,OAQjCtP,GAAO,aAAeysB,EAGlBztB,EAAKwgB,UAAYxgB,EAAKwgB,SAASlb,SACjCtE,GAAO,IAAMhB,EAAKwgB,SAASlb,QAG7B,IAAIuoB,EAAYnsB,WAAW8b,EAASxd,EAAK4B,SAAS8B,UAKlD6pB,EAAOvrB,mBAAqB8rB,EAC5BP,EAAOrrB,OAAS4e,EAChByM,EAAOnrB,QAAU2J,EAEjBwhB,EAAOQ,OAAQ,EACfR,EAAOS,OAAQ,EACfT,EAAOU,IAAMjtB,EACbqsB,EAAKa,YAAYX,QAxDfnG,EAAG,IAAIjsB,MAAM,UAAY6E,EAAKuC,OAAS,IAAMvB,EAAM,gCA0DrD,SAAS8f,IACP9gB,EAAKQ,MAAM,kBAEPktB,GAAQrsB,IAIZqsB,GAAO,EAGFN,IACHptB,EAAKQ,MAAM,4DACXotB,IACAxG,EAAG,IAAI3nB,EAAO8N,mBAIlB,SAASugB,IACiB,WAApBnwB,KAAKgG,YAA+C,aAApBhG,KAAKgG,YACvCmd,IAIJ,SAAS8M,IACPhrB,aAAairB,GACbN,EAAOrrB,OAAS,KAChBqrB,EAAOvrB,mBAAqB,KAC5BurB,EAAOnrB,QAAU,KACjBirB,EAAKc,YAAYZ,GAGnB,SAASI,IACP,WACS9B,OAAO4B,UACP5B,OAAO4B,EAAS,WACvB,MAAOtqB,GACP0oB,OAAO4B,GAAU5B,OAAO4B,EAAS,gBAAaxuB,GAIlD,SAASue,IACPxd,EAAKQ,MAAM,yBACXa,GAAW,EACXusB,IACAxG,EAAG,IAAI3nB,EAAO+D,gBAGhB,SAASuI,IACP/L,EAAKQ,MAAM,uBAEPktB,GAAQrsB,IAIZusB,IACAxG,EAAG,IAAI3nB,EAAO+N","file":"js/chunk-vendors~047ce45f.8b3ec9b8.js","sourcesContent":["'use strict';\n\nvar reduce = require('lodash/reduce');\nvar find = require('lodash/find');\nvar startsWith = require('lodash/startsWith');\n\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 * @return {array.<string[]>} array containing 2 elements : attributes, orders\n */\nmodule.exports = function formatSort(sortBy, defaults) {\n  return reduce(sortBy, function preparePredicate(out, sortInstruction) {\n    var sortInstructions = sortInstruction.split(':');\n    if (defaults && sortInstructions.length === 1) {\n      var similarDefault = find(defaults, function(predicate) {\n        return startsWith(predicate, sortInstruction[0]);\n      });\n      if (similarDefault) {\n        sortInstructions = similarDefault.split(':');\n      }\n    }\n    out[0].push(sortInstructions[0]);\n    out[1].push(sortInstructions[1]);\n    return out;\n  }, [[], []]);\n};\n","'use strict';\n\nmodule.exports = '3.32.0';\n","'use strict';\n\nvar invert = require('lodash/invert');\nvar keys = require('lodash/keys');\n\nvar keys2Short = {\n  advancedSyntax: 'aS',\n  allowTyposOnNumericTokens: 'aTONT',\n  analyticsTags: 'aT',\n  analytics: 'a',\n  aroundLatLngViaIP: 'aLLVIP',\n  aroundLatLng: 'aLL',\n  aroundPrecision: 'aP',\n  aroundRadius: 'aR',\n  attributesToHighlight: 'aTH',\n  attributesToRetrieve: 'aTR',\n  attributesToSnippet: 'aTS',\n  disjunctiveFacetsRefinements: 'dFR',\n  disjunctiveFacets: 'dF',\n  distinct: 'd',\n  facetsExcludes: 'fE',\n  facetsRefinements: 'fR',\n  facets: 'f',\n  getRankingInfo: 'gRI',\n  hierarchicalFacetsRefinements: 'hFR',\n  hierarchicalFacets: 'hF',\n  highlightPostTag: 'hPoT',\n  highlightPreTag: 'hPrT',\n  hitsPerPage: 'hPP',\n  ignorePlurals: 'iP',\n  index: 'idx',\n  insideBoundingBox: 'iBB',\n  insidePolygon: 'iPg',\n  length: 'l',\n  maxValuesPerFacet: 'mVPF',\n  minimumAroundRadius: 'mAR',\n  minProximity: 'mP',\n  minWordSizefor1Typo: 'mWS1T',\n  minWordSizefor2Typos: 'mWS2T',\n  numericFilters: 'nF',\n  numericRefinements: 'nR',\n  offset: 'o',\n  optionalWords: 'oW',\n  page: 'p',\n  queryType: 'qT',\n  query: 'q',\n  removeWordsIfNoResults: 'rWINR',\n  replaceSynonymsInHighlight: 'rSIH',\n  restrictSearchableAttributes: 'rSA',\n  synonyms: 's',\n  tagFilters: 'tF',\n  tagRefinements: 'tR',\n  typoTolerance: 'tT',\n  optionalTagFilters: 'oTF',\n  optionalFacetFilters: 'oFF',\n  snippetEllipsisText: 'sET',\n  disableExactOnAttributes: 'dEOA',\n  enableExactOnSingleWordQuery: 'eEOSWQ'\n};\n\nvar short2Keys = invert(keys2Short);\n\nmodule.exports = {\n  /**\n   * All the keys of the state, encoded.\n   * @const\n   */\n  ENCODED_PARAMETERS: keys(short2Keys),\n  /**\n   * Decode a shorten attribute\n   * @param {string} shortKey the shorten attribute\n   * @return {string} the decoded attribute, undefined otherwise\n   */\n  decode: function(shortKey) {\n    return short2Keys[shortKey];\n  },\n  /**\n   * Encode an attribute into a short version\n   * @param {string} key the attribute\n   * @return {string} the shorten attribute\n   */\n  encode: function(key) {\n    return keys2Short[key];\n  }\n};\n","'use strict';\n\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\nvar isUndefined = require('lodash/isUndefined');\nvar isString = require('lodash/isString');\nvar isFunction = require('lodash/isFunction');\nvar isEmpty = require('lodash/isEmpty');\nvar defaults = require('lodash/defaults');\n\nvar reduce = require('lodash/reduce');\nvar filter = require('lodash/filter');\nvar omit = require('lodash/omit');\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\n    var facetRefinement = !refinementList[attribute] ?\n      [valueAsString] :\n      refinementList[attribute].concat(valueAsString);\n\n    var mod = {};\n\n    mod[attribute] = facetRefinement;\n\n    return defaults({}, mod, refinementList);\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 (isUndefined(value)) {\n      return lib.clearRefinement(refinementList, attribute);\n    }\n\n    var valueAsString = '' + value;\n\n    return lib.clearRefinement(refinementList, function(v, f) {\n      return attribute === f && valueAsString === v;\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 (isUndefined(value)) 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   * 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 (isUndefined(attribute)) {\n      if (isEmpty(refinementList)) return refinementList;\n      return {};\n    } else if (isString(attribute)) {\n      if (isEmpty(refinementList[attribute])) return refinementList;\n      return omit(refinementList, attribute);\n    } else if (isFunction(attribute)) {\n      var hasChanged = false;\n\n      var newRefinementList = reduce(refinementList, function(memo, values, key) {\n        var facetList = filter(values, function(value) {\n          return !attribute(value, key, refinementType);\n        });\n\n        if (!isEmpty(facetList)) {\n          if (facetList.length !== values.length) hasChanged = true;\n          memo[key] = facetList;\n        }\n        else hasChanged = true;\n\n        return memo;\n      }, {});\n\n      if (hasChanged) return newRefinementList;\n      return refinementList;\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 indexOf = require('lodash/indexOf');\n\n    var containsRefinements = !!refinementList[attribute] &&\n      refinementList[attribute].length > 0;\n\n    if (isUndefined(refinementValue) || !containsRefinements) {\n      return containsRefinements;\n    }\n\n    var refinementValueAsString = '' + refinementValue;\n\n    return indexOf(refinementList[attribute], refinementValueAsString) !== -1;\n  }\n};\n\nmodule.exports = lib;\n","module.exports = function deprecatedMessage(previousUsage, newUsage) {\n  var githubAnchorLink = previousUsage.toLowerCase()\n    .replace(/[\\.\\(\\)]/g, '');\n\n  return 'algoliasearch: `' + previousUsage + '` was replaced by `' + newUsage +\n    '`. Please see https://github.com/algolia/algoliasearch-client-javascript/wiki/Deprecated#' + githubAnchorLink;\n};\n","'use strict';\n\nvar forEach = require('lodash/forEach');\nvar filter = require('lodash/filter');\nvar map = require('lodash/map');\nvar isEmpty = require('lodash/isEmpty');\nvar indexOf = require('lodash/indexOf');\n\nfunction filterState(state, filters) {\n  var partialState = {};\n  var attributeFilters = filter(filters, function(f) { return f.indexOf('attribute:') !== -1; });\n  var attributes = map(attributeFilters, function(aF) { return aF.split(':')[1]; });\n\n  if (indexOf(attributes, '*') === -1) {\n    forEach(attributes, function(attr) {\n      if (state.isConjunctiveFacet(attr) && state.isFacetRefined(attr)) {\n        if (!partialState.facetsRefinements) partialState.facetsRefinements = {};\n        partialState.facetsRefinements[attr] = state.facetsRefinements[attr];\n      }\n\n      if (state.isDisjunctiveFacet(attr) && state.isDisjunctiveFacetRefined(attr)) {\n        if (!partialState.disjunctiveFacetsRefinements) partialState.disjunctiveFacetsRefinements = {};\n        partialState.disjunctiveFacetsRefinements[attr] = state.disjunctiveFacetsRefinements[attr];\n      }\n\n      if (state.isHierarchicalFacet(attr) && state.isHierarchicalFacetRefined(attr)) {\n        if (!partialState.hierarchicalFacetsRefinements) partialState.hierarchicalFacetsRefinements = {};\n        partialState.hierarchicalFacetsRefinements[attr] = state.hierarchicalFacetsRefinements[attr];\n      }\n\n      var numericRefinements = state.getNumericRefinements(attr);\n      if (!isEmpty(numericRefinements)) {\n        if (!partialState.numericRefinements) partialState.numericRefinements = {};\n        partialState.numericRefinements[attr] = state.numericRefinements[attr];\n      }\n    });\n  } else {\n    if (!isEmpty(state.numericRefinements)) {\n      partialState.numericRefinements = state.numericRefinements;\n    }\n    if (!isEmpty(state.facetsRefinements)) partialState.facetsRefinements = state.facetsRefinements;\n    if (!isEmpty(state.disjunctiveFacetsRefinements)) {\n      partialState.disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements;\n    }\n    if (!isEmpty(state.hierarchicalFacetsRefinements)) {\n      partialState.hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements;\n    }\n  }\n\n  var searchParameters = filter(\n    filters,\n    function(f) {\n      return f.indexOf('attribute:') === -1;\n    }\n  );\n\n  forEach(\n    searchParameters,\n    function(parameterKey) {\n      partialState[parameterKey] = state[parameterKey];\n    }\n  );\n\n  return partialState;\n}\n\nmodule.exports = filterState;\n","'use strict';\nvar util = require('util');\nvar events = require('events');\n\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 */\nfunction DerivedHelper(mainHelper, fn) {\n  this.main = mainHelper;\n  this.fn = fn;\n  this.lastResults = null;\n}\n\nutil.inherits(DerivedHelper, events.EventEmitter);\n\n/**\n * Detach this helper from the main helper\n * @return {undefined}\n * @throws Error if the derived helper is already detached\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;\n","var foreach = require('foreach');\n\nmodule.exports = function merge(destination/* , sources */) {\n  var sources = Array.prototype.slice.call(arguments);\n\n  foreach(sources, function(source) {\n    for (var keyName in source) {\n      if (source.hasOwnProperty(keyName)) {\n        if (typeof destination[keyName] === 'object' && typeof source[keyName] === 'object') {\n          destination[keyName] = merge({}, destination[keyName], source[keyName]);\n        } else if (source[keyName] !== undefined) {\n          destination[keyName] = source[keyName];\n        }\n      }\n    }\n  });\n\n  return destination;\n};\n","module.exports = function omit(obj, test) {\n  var keys = require('object-keys');\n  var foreach = require('foreach');\n\n  var filtered = {};\n\n  foreach(keys(obj), function doFilter(keyName) {\n    if (test(keyName) !== true) {\n      filtered[keyName] = obj[keyName];\n    }\n  });\n\n  return filtered;\n};\n","'use strict';\n\nvar global = require('global');\nvar Promise = global.Promise || require('es6-promise').Promise;\n\n// This is the standalone browser build entry point\n// Browser implementation of the Algolia Search JavaScript client,\n// using XMLHttpRequest, XDomainRequest and JSONP as fallback\nmodule.exports = function createAlgoliasearch(AlgoliaSearch, uaSuffix) {\n  var inherits = require('inherits');\n  var errors = require('../errors');\n  var inlineHeaders = require('./inline-headers');\n  var jsonpRequest = require('./jsonp-request');\n  var places = require('../places.js');\n  uaSuffix = uaSuffix || '';\n\n  if (process.env.NODE_ENV === 'debug') {\n    require('debug').enable('algoliasearch*');\n  }\n\n  function algoliasearch(applicationID, apiKey, opts) {\n    var cloneDeep = require('../clone.js');\n\n    opts = cloneDeep(opts || {});\n\n    opts._ua = opts._ua || algoliasearch.ua;\n\n    return new AlgoliaSearchBrowser(applicationID, apiKey, opts);\n  }\n\n  algoliasearch.version = require('../version.js');\n  algoliasearch.ua = 'Algolia for vanilla JavaScript ' + uaSuffix + algoliasearch.version;\n  algoliasearch.initPlaces = places(algoliasearch);\n\n  // we expose into window no matter how we are used, this will allow\n  // us to easily debug any website running algolia\n  global.__algolia = {\n    debug: require('debug'),\n    algoliasearch: algoliasearch\n  };\n\n  var support = {\n    hasXMLHttpRequest: 'XMLHttpRequest' in global,\n    hasXDomainRequest: 'XDomainRequest' in global\n  };\n\n  if (support.hasXMLHttpRequest) {\n    support.cors = 'withCredentials' in new XMLHttpRequest();\n  }\n\n  function AlgoliaSearchBrowser() {\n    // call AlgoliaSearch constructor\n    AlgoliaSearch.apply(this, arguments);\n  }\n\n  inherits(AlgoliaSearchBrowser, AlgoliaSearch);\n\n  AlgoliaSearchBrowser.prototype._request = function request(url, opts) {\n    return new Promise(function wrapRequest(resolve, reject) {\n      // no cors or XDomainRequest, no request\n      if (!support.cors && !support.hasXDomainRequest) {\n        // very old browser, not supported\n        reject(new errors.Network('CORS not supported'));\n        return;\n      }\n\n      url = inlineHeaders(url, opts.headers);\n\n      var body = opts.body;\n      var req = support.cors ? new XMLHttpRequest() : new XDomainRequest();\n      var reqTimeout;\n      var timedOut;\n      var connected = false;\n\n      reqTimeout = setTimeout(onTimeout, opts.timeouts.connect);\n      // we set an empty onprogress listener\n      // so that XDomainRequest on IE9 is not aborted\n      // refs:\n      //  - https://github.com/algolia/algoliasearch-client-js/issues/76\n      //  - https://social.msdn.microsoft.com/Forums/ie/en-US/30ef3add-767c-4436-b8a9-f1ca19b4812e/ie9-rtm-xdomainrequest-issued-requests-may-abort-if-all-event-handlers-not-specified?forum=iewebdevelopment\n      req.onprogress = onProgress;\n      if ('onreadystatechange' in req) req.onreadystatechange = onReadyStateChange;\n      req.onload = onLoad;\n      req.onerror = onError;\n\n      // do not rely on default XHR async flag, as some analytics code like hotjar\n      // breaks it and set it to false by default\n      if (req instanceof XMLHttpRequest) {\n        req.open(opts.method, url, true);\n\n        // The Analytics API never accepts Auth headers as query string\n        // this option exists specifically for them.\n        if (opts.forceAuthHeaders) {\n          req.setRequestHeader(\n            'x-algolia-application-id',\n            opts.headers['x-algolia-application-id']\n          );\n          req.setRequestHeader(\n            'x-algolia-api-key',\n            opts.headers['x-algolia-api-key']\n          );\n        }\n      } else {\n        req.open(opts.method, url);\n      }\n\n      // headers are meant to be sent after open\n      if (support.cors) {\n        if (body) {\n          if (opts.method === 'POST') {\n            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Simple_requests\n            req.setRequestHeader('content-type', 'application/x-www-form-urlencoded');\n          } else {\n            req.setRequestHeader('content-type', 'application/json');\n          }\n        }\n        req.setRequestHeader('accept', 'application/json');\n      }\n\n      if (body) {\n        req.send(body);\n      } else {\n        req.send();\n      }\n\n      // event object not received in IE8, at least\n      // but we do not use it, still important to note\n      function onLoad(/* event */) {\n        // When browser does not supports req.timeout, we can\n        // have both a load and timeout event, since handled by a dumb setTimeout\n        if (timedOut) {\n          return;\n        }\n\n        clearTimeout(reqTimeout);\n\n        var out;\n\n        try {\n          out = {\n            body: JSON.parse(req.responseText),\n            responseText: req.responseText,\n            statusCode: req.status,\n            // XDomainRequest does not have any response headers\n            headers: req.getAllResponseHeaders && req.getAllResponseHeaders() || {}\n          };\n        } catch (e) {\n          out = new errors.UnparsableJSON({\n            more: req.responseText\n          });\n        }\n\n        if (out instanceof errors.UnparsableJSON) {\n          reject(out);\n        } else {\n          resolve(out);\n        }\n      }\n\n      function onError(event) {\n        if (timedOut) {\n          return;\n        }\n\n        clearTimeout(reqTimeout);\n\n        // error event is trigerred both with XDR/XHR on:\n        //   - DNS error\n        //   - unallowed cross domain request\n        reject(\n          new errors.Network({\n            more: event\n          })\n        );\n      }\n\n      function onTimeout() {\n        timedOut = true;\n        req.abort();\n\n        reject(new errors.RequestTimeout());\n      }\n\n      function onConnect() {\n        connected = true;\n        clearTimeout(reqTimeout);\n        reqTimeout = setTimeout(onTimeout, opts.timeouts.complete);\n      }\n\n      function onProgress() {\n        if (!connected) onConnect();\n      }\n\n      function onReadyStateChange() {\n        if (!connected && req.readyState > 1) onConnect();\n      }\n    });\n  };\n\n  AlgoliaSearchBrowser.prototype._request.fallback = function requestFallback(url, opts) {\n    url = inlineHeaders(url, opts.headers);\n\n    return new Promise(function wrapJsonpRequest(resolve, reject) {\n      jsonpRequest(url, opts, function jsonpRequestDone(err, content) {\n        if (err) {\n          reject(err);\n          return;\n        }\n\n        resolve(content);\n      });\n    });\n  };\n\n  AlgoliaSearchBrowser.prototype._promise = {\n    reject: function rejectPromise(val) {\n      return Promise.reject(val);\n    },\n    resolve: function resolvePromise(val) {\n      return Promise.resolve(val);\n    },\n    delay: function delayPromise(ms) {\n      return new Promise(function resolveOnTimeout(resolve/* , reject*/) {\n        setTimeout(resolve, ms);\n      });\n    },\n    all: function all(promises) {\n      return Promise.all(promises);\n    }\n  };\n\n  return algoliasearch;\n};\n","'use strict';\n\nvar AlgoliaSearchHelper = require('./src/algoliasearch.helper');\n\nvar SearchParameters = require('./src/SearchParameters');\nvar SearchResults = require('./src/SearchResults');\n\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(result) {\n *   console.log(result);\n * });\n * helper.toggleRefine('Movies & TV Shows')\n *       .toggleRefine('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 */\nfunction algoliasearchHelper(client, index, opts) {\n  return new AlgoliaSearchHelper(client, index, opts);\n}\n\n/**\n * The version currently used\n * @member module:algoliasearchHelper.version\n * @type {number}\n */\nalgoliasearchHelper.version = require('./src/version.js');\n\n/**\n * Constructor for the Helper.\n * @member module:algoliasearchHelper.AlgoliaSearchHelper\n * @type {AlgoliaSearchHelper}\n */\nalgoliasearchHelper.AlgoliaSearchHelper = AlgoliaSearchHelper;\n\n/**\n * Constructor for the object containing all the parameters of the search.\n * @member module:algoliasearchHelper.SearchParameters\n * @type {SearchParameters}\n */\nalgoliasearchHelper.SearchParameters = SearchParameters;\n\n/**\n * Constructor for the object containing the results of the search.\n * @member module:algoliasearchHelper.SearchResults\n * @type {SearchResults}\n */\nalgoliasearchHelper.SearchResults = SearchResults;\n\n/**\n * URL tools to generate query string and parse them from/into\n * SearchParameters\n * @member module:algoliasearchHelper.url\n * @type {object} {@link url}\n *\n */\nalgoliasearchHelper.url = require('./src/url');\n\nmodule.exports = algoliasearchHelper;\n","'use strict';\n\nvar keys = require('lodash/keys');\nvar intersection = require('lodash/intersection');\nvar forOwn = require('lodash/forOwn');\nvar forEach = require('lodash/forEach');\nvar filter = require('lodash/filter');\nvar map = require('lodash/map');\nvar reduce = require('lodash/reduce');\nvar omit = require('lodash/omit');\nvar indexOf = require('lodash/indexOf');\nvar isNaN = require('lodash/isNaN');\nvar isEmpty = require('lodash/isEmpty');\nvar isEqual = require('lodash/isEqual');\nvar isUndefined = require('lodash/isUndefined');\nvar isString = require('lodash/isString');\nvar isFunction = require('lodash/isFunction');\nvar find = require('lodash/find');\nvar trim = require('lodash/trim');\n\nvar defaults = require('lodash/defaults');\nvar merge = require('lodash/merge');\n\nvar valToNumber = require('../functions/valToNumber');\n\nvar filterState = require('./filterState');\n\nvar RefinementList = require('./RefinementList');\n\n/**\n * like _.find but using _.isEqual to be able to use it\n * to find arrays.\n * @private\n * @param {any[]} array array to search into\n * @param {any} searchedValue the value we're looking for\n * @return {any} the searched value or undefined\n */\nfunction findArray(array, searchedValue) {\n  return find(array, function(currentValue) {\n    return isEqual(currentValue, searchedValue);\n  });\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 */\nfunction SearchParameters(newParameters) {\n  var params = newParameters ? SearchParameters._parseNumbers(newParameters) : {};\n\n  /**\n   * Targeted index. This parameter is mandatory.\n   * @member {string}\n   */\n  this.index = params.index || '';\n\n  // Query\n  /**\n   * Query string of the instant search. The empty string is a valid query.\n   * @member {string}\n   * @see https://www.algolia.com/doc/rest#param-query\n   */\n  this.query = params.query || '';\n\n  // Facets\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  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  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  this.hierarchicalFacets = params.hierarchicalFacets || [];\n\n  // Refinements\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  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  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  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  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  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  this.hierarchicalFacetsRefinements = params.hierarchicalFacetsRefinements || {};\n\n  /**\n   * Contains the numeric filters in the raw format of the Algolia API. Setting\n   * this parameter is not compatible with the usage of numeric filters methods.\n   * @see https://www.algolia.com/doc/javascript#numericFilters\n   * @member {string}\n   */\n  this.numericFilters = params.numericFilters;\n\n  /**\n   * Contains the tag filters in the raw format of the Algolia API. Setting this\n   * parameter is not compatible with the of the add/remove/toggle methods of the\n   * tag api.\n   * @see https://www.algolia.com/doc/rest#param-tagFilters\n   * @member {string}\n   */\n  this.tagFilters = params.tagFilters;\n\n  /**\n   * Contains the optional tag filters in the raw format of the Algolia API.\n   * @see https://www.algolia.com/doc/rest#param-tagFilters\n   * @member {string}\n   */\n  this.optionalTagFilters = params.optionalTagFilters;\n\n  /**\n   * Contains the optional facet filters in the raw format of the Algolia API.\n   * @see https://www.algolia.com/doc/rest#param-tagFilters\n   * @member {string}\n   */\n  this.optionalFacetFilters = params.optionalFacetFilters;\n\n\n  // Misc. parameters\n  /**\n   * Number of hits to be returned by the search API\n   * @member {number}\n   * @see https://www.algolia.com/doc/rest#param-hitsPerPage\n   */\n  this.hitsPerPage = params.hitsPerPage;\n  /**\n   * Number of values for each faceted attribute\n   * @member {number}\n   * @see https://www.algolia.com/doc/rest#param-maxValuesPerFacet\n   */\n  this.maxValuesPerFacet = params.maxValuesPerFacet;\n  /**\n   * The current page number\n   * @member {number}\n   * @see https://www.algolia.com/doc/rest#param-page\n   */\n  this.page = params.page || 0;\n  /**\n   * How the query should be treated by the search engine.\n   * Possible values: prefixAll, prefixLast, prefixNone\n   * @see https://www.algolia.com/doc/rest#param-queryType\n   * @member {string}\n   */\n  this.queryType = params.queryType;\n  /**\n   * How the typo tolerance behave in the search engine.\n   * Possible values: true, false, min, strict\n   * @see https://www.algolia.com/doc/rest#param-typoTolerance\n   * @member {string}\n   */\n  this.typoTolerance = params.typoTolerance;\n\n  /**\n   * Number of characters to wait before doing one character replacement.\n   * @see https://www.algolia.com/doc/rest#param-minWordSizefor1Typo\n   * @member {number}\n   */\n  this.minWordSizefor1Typo = params.minWordSizefor1Typo;\n  /**\n   * Number of characters to wait before doing a second character replacement.\n   * @see https://www.algolia.com/doc/rest#param-minWordSizefor2Typos\n   * @member {number}\n   */\n  this.minWordSizefor2Typos = params.minWordSizefor2Typos;\n  /**\n   * Configure the precision of the proximity ranking criterion\n   * @see https://www.algolia.com/doc/rest#param-minProximity\n   */\n  this.minProximity = params.minProximity;\n  /**\n   * Should the engine allow typos on numerics.\n   * @see https://www.algolia.com/doc/rest#param-allowTyposOnNumericTokens\n   * @member {boolean}\n   */\n  this.allowTyposOnNumericTokens = params.allowTyposOnNumericTokens;\n  /**\n   * Should the plurals be ignored\n   * @see https://www.algolia.com/doc/rest#param-ignorePlurals\n   * @member {boolean}\n   */\n  this.ignorePlurals = params.ignorePlurals;\n  /**\n   * Restrict which attribute is searched.\n   * @see https://www.algolia.com/doc/rest#param-restrictSearchableAttributes\n   * @member {string}\n   */\n  this.restrictSearchableAttributes = params.restrictSearchableAttributes;\n  /**\n   * Enable the advanced syntax.\n   * @see https://www.algolia.com/doc/rest#param-advancedSyntax\n   * @member {boolean}\n   */\n  this.advancedSyntax = params.advancedSyntax;\n  /**\n   * Enable the analytics\n   * @see https://www.algolia.com/doc/rest#param-analytics\n   * @member {boolean}\n   */\n  this.analytics = params.analytics;\n  /**\n   * Tag of the query in the analytics.\n   * @see https://www.algolia.com/doc/rest#param-analyticsTags\n   * @member {string}\n   */\n  this.analyticsTags = params.analyticsTags;\n  /**\n   * Enable the synonyms\n   * @see https://www.algolia.com/doc/rest#param-synonyms\n   * @member {boolean}\n   */\n  this.synonyms = params.synonyms;\n  /**\n   * Should the engine replace the synonyms in the highlighted results.\n   * @see https://www.algolia.com/doc/rest#param-replaceSynonymsInHighlight\n   * @member {boolean}\n   */\n  this.replaceSynonymsInHighlight = params.replaceSynonymsInHighlight;\n  /**\n   * Add some optional words to those defined in the dashboard\n   * @see https://www.algolia.com/doc/rest#param-optionalWords\n   * @member {string}\n   */\n  this.optionalWords = params.optionalWords;\n  /**\n   * Possible values are \"lastWords\" \"firstWords\" \"allOptional\" \"none\" (default)\n   * @see https://www.algolia.com/doc/rest#param-removeWordsIfNoResults\n   * @member {string}\n   */\n  this.removeWordsIfNoResults = params.removeWordsIfNoResults;\n  /**\n   * List of attributes to retrieve\n   * @see https://www.algolia.com/doc/rest#param-attributesToRetrieve\n   * @member {string}\n   */\n  this.attributesToRetrieve = params.attributesToRetrieve;\n  /**\n   * List of attributes to highlight\n   * @see https://www.algolia.com/doc/rest#param-attributesToHighlight\n   * @member {string}\n   */\n  this.attributesToHighlight = params.attributesToHighlight;\n  /**\n   * Code to be embedded on the left part of the highlighted results\n   * @see https://www.algolia.com/doc/rest#param-highlightPreTag\n   * @member {string}\n   */\n  this.highlightPreTag = params.highlightPreTag;\n  /**\n   * Code to be embedded on the right part of the highlighted results\n   * @see https://www.algolia.com/doc/rest#param-highlightPostTag\n   * @member {string}\n   */\n  this.highlightPostTag = params.highlightPostTag;\n  /**\n   * List of attributes to snippet\n   * @see https://www.algolia.com/doc/rest#param-attributesToSnippet\n   * @member {string}\n   */\n  this.attributesToSnippet = params.attributesToSnippet;\n  /**\n   * Enable the ranking informations in the response, set to 1 to activate\n   * @see https://www.algolia.com/doc/rest#param-getRankingInfo\n   * @member {number}\n   */\n  this.getRankingInfo = params.getRankingInfo;\n  /**\n   * Remove duplicates based on the index setting attributeForDistinct\n   * @see https://www.algolia.com/doc/rest#param-distinct\n   * @member {boolean|number}\n   */\n  this.distinct = params.distinct;\n  /**\n   * Center of the geo search.\n   * @see https://www.algolia.com/doc/rest#param-aroundLatLng\n   * @member {string}\n   */\n  this.aroundLatLng = params.aroundLatLng;\n  /**\n   * Center of the search, retrieve from the user IP.\n   * @see https://www.algolia.com/doc/rest#param-aroundLatLngViaIP\n   * @member {boolean}\n   */\n  this.aroundLatLngViaIP = params.aroundLatLngViaIP;\n  /**\n   * Radius of the geo search.\n   * @see https://www.algolia.com/doc/rest#param-aroundRadius\n   * @member {number}\n   */\n  this.aroundRadius = params.aroundRadius;\n  /**\n   * Precision of the geo search.\n   * @see https://www.algolia.com/doc/rest#param-aroundPrecision\n   * @member {number}\n   */\n  this.minimumAroundRadius = params.minimumAroundRadius;\n  /**\n   * Precision of the geo search.\n   * @see https://www.algolia.com/doc/rest#param-minimumAroundRadius\n   * @member {number}\n   */\n  this.aroundPrecision = params.aroundPrecision;\n  /**\n   * Geo search inside a box.\n   * @see https://www.algolia.com/doc/rest#param-insideBoundingBox\n   * @member {string}\n   */\n  this.insideBoundingBox = params.insideBoundingBox;\n  /**\n   * Geo search inside a polygon.\n   * @see https://www.algolia.com/doc/rest#param-insidePolygon\n   * @member {string}\n   */\n  this.insidePolygon = params.insidePolygon;\n  /**\n   * Allows to specify an ellipsis character for the snippet when we truncate the text\n   * (added before and after if truncated).\n   * The default value is an empty string and we recommend to set it to \"…\"\n   * @see https://www.algolia.com/doc/rest#param-insidePolygon\n   * @member {string}\n   */\n  this.snippetEllipsisText = params.snippetEllipsisText;\n  /**\n   * Allows to specify some attributes name on which exact won't be applied.\n   * Attributes are separated with a comma (for example \"name,address\" ), you can also use a\n   * JSON string array encoding (for example encodeURIComponent('[\"name\",\"address\"]') ).\n   * By default the list is empty.\n   * @see https://www.algolia.com/doc/rest#param-disableExactOnAttributes\n   * @member {string|string[]}\n   */\n  this.disableExactOnAttributes = params.disableExactOnAttributes;\n  /**\n   * Applies 'exact' on single word queries if the word contains at least 3 characters\n   * and is not a stop word.\n   * Can take two values: true or false.\n   * By default, its set to false.\n   * @see https://www.algolia.com/doc/rest#param-enableExactOnSingleWordQuery\n   * @member {boolean}\n   */\n  this.enableExactOnSingleWordQuery = params.enableExactOnSingleWordQuery;\n\n  // Undocumented parameters, still needed otherwise we fail\n  this.offset = params.offset;\n  this.length = params.length;\n\n  var self = this;\n  forOwn(params, function checkForUnknownParameter(paramValue, paramName) {\n    if (SearchParameters.PARAMETERS.indexOf(paramName) === -1) {\n      self[paramName] = paramValue;\n    }\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 */\nSearchParameters.PARAMETERS = keys(new SearchParameters());\n\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 */\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\n  var numbers = {};\n\n  var numberKeys = [\n    'aroundPrecision',\n    'aroundRadius',\n    'getRankingInfo',\n    'minWordSizefor2Typos',\n    'minWordSizefor1Typo',\n    'page',\n    'maxValuesPerFacet',\n    'distinct',\n    'minimumAroundRadius',\n    'hitsPerPage',\n    'minProximity'\n  ];\n\n  forEach(numberKeys, function(k) {\n    var value = partialState[k];\n    if (isString(value)) {\n      var parsedValue = parseFloat(value);\n      numbers[k] = isNaN(parsedValue) ? value : parsedValue;\n    }\n  });\n\n  // there's two formats of insideBoundingBox, we need to parse\n  // the one which is an array of float geo rectangles\n  if (Array.isArray(partialState.insideBoundingBox)) {\n    numbers.insideBoundingBox = partialState.insideBoundingBox.map(function(geoRect) {\n      return geoRect.map(function(value) {\n        return parseFloat(value);\n      });\n    });\n  }\n\n  if (partialState.numericRefinements) {\n    var numericRefinements = {};\n    forEach(partialState.numericRefinements, function(operators, attribute) {\n      numericRefinements[attribute] = {};\n      forEach(operators, function(values, operator) {\n        var parsedValues = map(values, function(v) {\n          if (Array.isArray(v)) {\n            return map(v, function(vPrime) {\n              if (isString(vPrime)) {\n                return parseFloat(vPrime);\n              }\n              return vPrime;\n            });\n          } else if (isString(v)) {\n            return parseFloat(v);\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/**\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 */\nSearchParameters.make = function makeSearchParameters(newParameters) {\n  var instance = new SearchParameters(newParameters);\n\n  forEach(newParameters.hierarchicalFacets, 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      }\n\n      // get it again in case it has been cleared\n      currentRefinement = instance.getHierarchicalRefinement(facet.name);\n      if (currentRefinement.length === 0) {\n        instance = instance.toggleHierarchicalFacetRefinement(facet.name, facet.rootPath);\n      }\n    }\n  });\n\n  return instance;\n};\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 */\nSearchParameters.validate = function(currentState, parameters) {\n  var params = parameters || {};\n\n  if (currentState.tagFilters && params.tagRefinements && params.tagRefinements.length > 0) {\n    return new Error(\n      '[Tags] Cannot switch from the managed tag API to the advanced API. It is probably ' +\n      '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(\n      '[Tags] Cannot switch from the advanced tag API to the managed API. It is probably ' +\n      'an error, if it is not, you should first clear the tags with clearTags method.');\n  }\n\n  if (currentState.numericFilters && params.numericRefinements && !isEmpty(params.numericRefinements)) {\n    return new Error(\n      \"[Numeric filters] Can't switch from the advanced to the managed API. It\" +\n      ' is probably an error, if this is really what you want, you have to first' +\n      ' clear the numeric filters.');\n  }\n\n  if (!isEmpty(currentState.numericRefinements) && params.numericFilters) {\n    return new Error(\n      \"[Numeric filters] Can't switch from the managed API to the advanced. It\" +\n      ' is probably an error, if this is really what you want, you have to first' +\n      ' 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 clear = RefinementList.clearRefinement;\n    var patch = {\n      numericRefinements: this._clearNumericRefinements(attribute),\n      facetsRefinements: clear(this.facetsRefinements, attribute, 'conjunctiveFacet'),\n      facetsExcludes: clear(this.facetsExcludes, attribute, 'exclude'),\n      disjunctiveFacetsRefinements: clear(this.disjunctiveFacetsRefinements, attribute, 'disjunctiveFacet'),\n      hierarchicalFacetsRefinements: clear(this.hierarchicalFacetsRefinements, attribute, 'hierarchicalFacet')\n    };\n    if (patch.numericRefinements === this.numericRefinements &&\n        patch.facetsRefinements === this.facetsRefinements &&\n        patch.facetsExcludes === this.facetsExcludes &&\n        patch.disjunctiveFacetsRefinements === this.disjunctiveFacetsRefinements &&\n        patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements) {\n      return this;\n    }\n    return this.setQueryParameters(patch);\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\n    return this.setQueryParameters({\n      tagFilters: undefined,\n      tagRefinements: []\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\n    return this.setQueryParameters({\n      index: index\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\n    return this.setQueryParameters({\n      query: newQuery\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\n    return this.setQueryParameters({\n      page: newPage\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   * 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   * 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\n    return this.setQueryParameters({\n      hitsPerPage: 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\n    return this.setQueryParameters({\n      typoTolerance: typoTolerance\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(attribute, operator, v) {\n    var value = valToNumber(v);\n\n    if (this.isNumericRefined(attribute, operator, value)) return this;\n\n    var mod = merge({}, this.numericRefinements);\n\n    mod[attribute] = merge({}, mod[attribute]);\n\n    if (mod[attribute][operator]) {\n      // Array copy\n      mod[attribute][operator] = mod[attribute][operator].slice();\n      // Add the element. Concat can't be used here because value can be an array.\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   * 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(facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      throw new Error(facetName + ' is not defined in the facets attribute of the helper configuration');\n    }\n    return this.facetsRefinements[facetName] || [];\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(facetName) {\n    if (!this.isDisjunctiveFacet(facetName)) {\n      throw new Error(\n        facetName + ' is not defined in the disjunctiveFacets attribute of the helper configuration'\n      );\n    }\n    return this.disjunctiveFacetsRefinements[facetName] || [];\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(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   * 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(facetName) {\n    if (!this.isConjunctiveFacet(facetName)) {\n      throw new Error(facetName + ' is not defined in the facets attribute of the helper configuration');\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(attribute, operator, paramValue) {\n    if (paramValue !== undefined) {\n      var paramValueAsNumber = valToNumber(paramValue);\n      if (!this.isNumericRefined(attribute, operator, paramValueAsNumber)) return this;\n      return this.setQueryParameters({\n        numericRefinements: this._clearNumericRefinements(function(value, key) {\n          return key === attribute && value.op === operator && isEqual(value.val, paramValueAsNumber);\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   * 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(facetName) {\n    return this.numericRefinements[facetName] || {};\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(attribute, operator) {\n    return this.numericRefinements[attribute] && this.numericRefinements[attribute][operator];\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 (isUndefined(attribute)) {\n      if (isEmpty(this.numericRefinements)) return this.numericRefinements;\n      return {};\n    } else if (isString(attribute)) {\n      if (isEmpty(this.numericRefinements[attribute])) return this.numericRefinements;\n      return omit(this.numericRefinements, attribute);\n    } else if (isFunction(attribute)) {\n      var hasChanged = false;\n      var newNumericRefinements = reduce(this.numericRefinements, function(memo, operators, key) {\n        var operatorList = {};\n\n        forEach(operators, function(values, operator) {\n          var outValues = [];\n          forEach(values, function(value) {\n            var predicateResult = attribute({val: value, op: operator}, key, 'numeric');\n            if (!predicateResult) outValues.push(value);\n          });\n          if (!isEmpty(outValues)) {\n            if (outValues.length !== values.length) hasChanged = true;\n            operatorList[operator] = outValues;\n          }\n          else hasChanged = true;\n        });\n\n        if (!isEmpty(operatorList)) memo[key] = operatorList;\n\n        return memo;\n      }, {});\n\n      if (hasChanged) return newNumericRefinements;\n      return this.numericRefinements;\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   * 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   * 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(\n        '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   * 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    if (RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.addRefinement(this.facetsRefinements, facet, value)\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    if (RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.addRefinement(this.facetsExcludes, facet, value)\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(\n        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\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.addRefinement(\n        this.disjunctiveFacetsRefinements, facet, value)\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\n    var modification = {\n      tagRefinements: this.tagRefinements.concat(tag)\n    };\n\n    return this.setQueryParameters(modification);\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: filter(this.facets, function(f) {\n        return f !== facet;\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: filter(this.disjunctiveFacets, function(f) {\n        return f !== facet;\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: filter(this.hierarchicalFacets, function(f) {\n        return f.name !== facet;\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    if (!RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;\n\n    return this.setQueryParameters({\n      facetsRefinements: RefinementList.removeRefinement(this.facetsRefinements, facet, value)\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    if (!RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;\n\n    return this.setQueryParameters({\n      facetsExcludes: RefinementList.removeRefinement(this.facetsExcludes, facet, value)\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(\n        facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n    if (!RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.removeRefinement(\n        this.disjunctiveFacetsRefinements, facet, value)\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\n    var modification = {\n      tagRefinements: filter(this.tagRefinements, function(t) { return t !== tag; })\n    };\n\n    return this.setQueryParameters(modification);\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   * 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 +\n      '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets');\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   * 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   * 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(\n        facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n\n    return this.setQueryParameters({\n      disjunctiveFacetsRefinements: RefinementList.toggleRefinement(\n        this.disjunctiveFacetsRefinements, facet, value)\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(\n        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\n    var upOneOrMultipleLevel = this.hierarchicalFacetsRefinements[facet] !== undefined &&\n      this.hierarchicalFacetsRefinements[facet].length > 0 && (\n      // remove current refinement:\n      // refinement was 'beer > IPA', call is toggleRefine('beer > IPA'), refinement should be `beer`\n      this.hierarchicalFacetsRefinements[facet][0] === value ||\n      // 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\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: defaults({}, 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(facet, path) {\n    if (this.isHierarchicalFacetRefined(facet)) {\n      throw new Error(facet + ' is already refined.');\n    }\n    var mod = {};\n    mod[facet] = [path];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaults({}, 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(facet) {\n    if (!this.isHierarchicalFacetRefined(facet)) {\n      throw new Error(facet + ' is not refined.');\n    }\n    var mod = {};\n    mod[facet] = [];\n    return this.setQueryParameters({\n      hierarchicalFacetsRefinements: defaults({}, mod, this.hierarchicalFacetsRefinements)\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   * 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(facet) {\n    return indexOf(this.disjunctiveFacets, facet) > -1;\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(facetName) {\n    return this.getHierarchicalFacetByName(facetName) !== undefined;\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(facet) {\n    return indexOf(this.facets, facet) > -1;\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      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n    return RefinementList.isRefined(this.facetsRefinements, facet, value);\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      throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');\n    }\n    return RefinementList.isRefined(this.facetsExcludes, facet, value);\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      throw new Error(\n        facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');\n    }\n    return RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value);\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      throw new Error(\n        facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration');\n    }\n\n    var refinements = this.getHierarchicalRefinement(facet);\n\n    if (!value) {\n      return refinements.length > 0;\n    }\n\n    return indexOf(refinements, value) !== -1;\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 (isUndefined(value) && isUndefined(operator)) {\n      return !!this.numericRefinements[attribute];\n    }\n\n    var isOperatorDefined = this.numericRefinements[attribute] &&\n      !isUndefined(this.numericRefinements[attribute][operator]);\n\n    if (isUndefined(value) || !isOperatorDefined) {\n      return isOperatorDefined;\n    }\n\n    var parsedValue = valToNumber(value);\n    var isAttributeValueDefined = !isUndefined(\n      findArray(this.numericRefinements[attribute][operator], parsedValue)\n    );\n\n    return isOperatorDefined && isAttributeValueDefined;\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 indexOf(this.tagRefinements, tag) !== -1;\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    // attributes used for numeric filter can also be disjunctive\n    var disjunctiveNumericRefinedFacets = intersection(\n      keys(this.numericRefinements),\n      this.disjunctiveFacets\n    );\n\n    return keys(this.disjunctiveFacetsRefinements)\n      .concat(disjunctiveNumericRefinedFacets)\n      .concat(this.getRefinedHierarchicalFacets());\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    return intersection(\n      // enforce the order between the two arrays,\n      // so that refinement name index === hierarchical facet index\n      map(this.hierarchicalFacets, 'name'),\n      keys(this.hierarchicalFacetsRefinements)\n    );\n  },\n  /**\n   * Returned the list of all disjunctive facets not refined\n   * @method\n   * @return {string[]}\n   */\n  getUnrefinedDisjunctiveFacets: function() {\n    var refinedFacets = this.getRefinedDisjunctiveFacets();\n\n    return filter(this.disjunctiveFacets, function(f) {\n      return indexOf(refinedFacets, f) === -1;\n    });\n  },\n\n  managedParameters: [\n    'index',\n    'facets', 'disjunctiveFacets', 'facetsRefinements',\n    'facetsExcludes', 'disjunctiveFacetsRefinements',\n    'numericRefinements', 'tagRefinements', 'hierarchicalFacets', 'hierarchicalFacetsRefinements'\n  ],\n  getQueryParams: function getQueryParams() {\n    var managedParameters = this.managedParameters;\n\n    var queryParams = {};\n\n    forOwn(this, function(paramValue, paramName) {\n      if (indexOf(managedParameters, paramName) === -1 && paramValue !== undefined) {\n        queryParams[paramName] = paramValue;\n      }\n    });\n\n    return queryParams;\n  },\n  /**\n   * Let the user retrieve any parameter value from the SearchParameters\n   * @param {string} paramName name of the parameter\n   * @return {any} the value of the parameter\n   */\n  getQueryParameter: function getQueryParameter(paramName) {\n    if (!this.hasOwnProperty(paramName)) {\n      throw new Error(\n        \"Parameter '\" + paramName + \"' is not an attribute of SearchParameters \" +\n        '(http://algolia.github.io/algoliasearch-helper-js/docs/SearchParameters.html)');\n    }\n\n    return this[paramName];\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\n    var modification = {};\n\n    modification[parameter] = value;\n\n    return this.setQueryParameters(modification);\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\n    var error = SearchParameters.validate(this, params);\n\n    if (error) {\n      throw error;\n    }\n\n    var parsedParams = SearchParameters._parseNumbers(params);\n\n    return this.mutateMe(function mergeWith(newInstance) {\n      var ks = keys(params);\n\n      forEach(ks, function(k) {\n        newInstance[k] = parsedParams[k];\n      });\n\n      return newInstance;\n    });\n  },\n\n  /**\n   * Returns an object with only the selected attributes.\n   * @param {string[]} filters filters to retrieve only a subset of the state. It\n   * accepts strings that can be either attributes of the SearchParameters (e.g. hitsPerPage)\n   * or attributes of the index with the notation 'attribute:nameOfMyAttribute'\n   * @return {object}\n   */\n  filter: function(filters) {\n    return filterState(this, filters);\n  },\n  /**\n   * Helper function to make it easier to build new instances from a mutating\n   * function\n   * @private\n   * @param {function} fn newMutableState -> previousState -> () function that will\n   * change the value of the newMutable to the desired state\n   * @return {SearchParameters} a new instance with the specified modifications applied\n   */\n  mutateMe: function mutateMe(fn) {\n    var newState = new this.constructor(this);\n\n    fn(newState, this);\n    return newState;\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(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(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(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(hierarchicalFacet) {\n    if (typeof hierarchicalFacet.showParentLevel === 'boolean') {\n      return hierarchicalFacet.showParentLevel;\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(hierarchicalFacetName) {\n    return find(\n      this.hierarchicalFacets,\n      {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(facetName) {\n    if (!this.isHierarchicalFacet(facetName)) {\n      throw new Error(\n        'Cannot get the breadcrumb of an unknown hierarchical facet: `' + facetName + '`');\n    }\n\n    var refinement = this.getHierarchicalRefinement(facetName)[0];\n    if (!refinement) return [];\n\n    var separator = this._getHierarchicalFacetSeparator(\n      this.getHierarchicalFacetByName(facetName)\n    );\n    var path = refinement.split(separator);\n    return map(path, trim);\n  },\n\n  toString: function() {\n    return JSON.stringify(this, null, 2);\n  }\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 */\nmodule.exports = SearchParameters;\n","'use strict';\n\n// This file hosts our error definitions\n// We use custom error \"types\" so that we can act on them when we need it\n// e.g.: if error instanceof errors.UnparsableJSON then..\n\nvar inherits = require('inherits');\n\nfunction AlgoliaSearchError(message, extraProperties) {\n  var forEach = require('foreach');\n\n  var error = this;\n\n  // try to get a stacktrace\n  if (typeof Error.captureStackTrace === 'function') {\n    Error.captureStackTrace(this, this.constructor);\n  } else {\n    error.stack = (new Error()).stack || 'Cannot get a stacktrace, browser is too old';\n  }\n\n  this.name = 'AlgoliaSearchError';\n  this.message = message || 'Unknown error';\n\n  if (extraProperties) {\n    forEach(extraProperties, function addToErrorObject(value, key) {\n      error[key] = value;\n    });\n  }\n}\n\ninherits(AlgoliaSearchError, Error);\n\nfunction createCustomError(name, message) {\n  function AlgoliaSearchCustomError() {\n    var args = Array.prototype.slice.call(arguments, 0);\n\n    // custom message not set, use default\n    if (typeof args[0] !== 'string') {\n      args.unshift(message);\n    }\n\n    AlgoliaSearchError.apply(this, args);\n    this.name = 'AlgoliaSearch' + name + 'Error';\n  }\n\n  inherits(AlgoliaSearchCustomError, AlgoliaSearchError);\n\n  return AlgoliaSearchCustomError;\n}\n\n// late exports to let various fn defs and inherits take place\nmodule.exports = {\n  AlgoliaSearchError: AlgoliaSearchError,\n  UnparsableJSON: createCustomError(\n    'UnparsableJSON',\n    'Could not parse the incoming response as JSON, see err.more for details'\n  ),\n  RequestTimeout: createCustomError(\n    'RequestTimeout',\n    'Request timedout before getting a response'\n  ),\n  Network: createCustomError(\n    'Network',\n    'Network issue, see err.more for details'\n  ),\n  JSONPScriptFail: createCustomError(\n    'JSONPScriptFail',\n    '<script> was loaded but did not call our provided callback'\n  ),\n  JSONPScriptError: createCustomError(\n    'JSONPScriptError',\n    '<script> unable to load due to an `error` event on it'\n  ),\n  Unknown: createCustomError(\n    'Unknown',\n    'Unknown error occured'\n  )\n};\n","'use strict';\n\nmodule.exports = inlineHeaders;\n\nvar encode = require('querystring-es3/encode');\n\nfunction inlineHeaders(url, headers) {\n  if (/\\?/.test(url)) {\n    url += '&';\n  } else {\n    url += '?';\n  }\n\n  return url + encode(headers);\n}\n","// Parse cloud does not supports setTimeout\n// We do not store a setTimeout reference in the client everytime\n// We only fallback to a fake setTimeout when not available\n// setTimeout cannot be override globally sadly\nmodule.exports = function exitPromise(fn, _setTimeout) {\n  _setTimeout(fn, 0);\n};\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug['default'] = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Previous log timestamp.\n */\n\nvar prevTime;\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n  var hash = 0, i;\n\n  for (i in namespace) {\n    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);\n    hash |= 0; // Convert to 32bit integer\n  }\n\n  return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n  function debug() {\n    // disabled?\n    if (!debug.enabled) return;\n\n    var self = debug;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // turn the `arguments` into a proper Array\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %O\n      args.unshift('%O');\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    // apply env-specific formatting (colors, etc.)\n    exports.formatArgs.call(self, args);\n\n    var logFn = debug.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n\n  debug.namespace = namespace;\n  debug.enabled = exports.enabled(namespace);\n  debug.useColors = exports.useColors();\n  debug.color = selectColor(namespace);\n\n  // env-specific initialization logic for debug instances\n  if ('function' === typeof exports.init) {\n    exports.init(debug);\n  }\n\n  return debug;\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  exports.names = [];\n  exports.skips = [];\n\n  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n","var debug = require('debug')('algoliasearch:src/hostIndexState.js');\nvar localStorageNamespace = 'algoliasearch-client-js';\n\nvar store;\nvar moduleStore = {\n  state: {},\n  set: function(key, data) {\n    this.state[key] = data;\n    return this.state[key];\n  },\n  get: function(key) {\n    return this.state[key] || null;\n  }\n};\n\nvar localStorageStore = {\n  set: function(key, data) {\n    moduleStore.set(key, data); // always replicate localStorageStore to moduleStore in case of failure\n\n    try {\n      var namespace = JSON.parse(global.localStorage[localStorageNamespace]);\n      namespace[key] = data;\n      global.localStorage[localStorageNamespace] = JSON.stringify(namespace);\n      return namespace[key];\n    } catch (e) {\n      return localStorageFailure(key, e);\n    }\n  },\n  get: function(key) {\n    try {\n      return JSON.parse(global.localStorage[localStorageNamespace])[key] || null;\n    } catch (e) {\n      return localStorageFailure(key, e);\n    }\n  }\n};\n\nfunction localStorageFailure(key, e) {\n  debug('localStorage failed with', e);\n  cleanup();\n  store = moduleStore;\n  return store.get(key);\n}\n\nstore = supportsLocalStorage() ? localStorageStore : moduleStore;\n\nmodule.exports = {\n  get: getOrSet,\n  set: getOrSet,\n  supportsLocalStorage: supportsLocalStorage\n};\n\nfunction getOrSet(key, data) {\n  if (arguments.length === 1) {\n    return store.get(key);\n  }\n\n  return store.set(key, data);\n}\n\nfunction supportsLocalStorage() {\n  try {\n    if ('localStorage' in global &&\n      global.localStorage !== null) {\n      if (!global.localStorage[localStorageNamespace]) {\n        // actual creation of the namespace\n        global.localStorage.setItem(localStorageNamespace, JSON.stringify({}));\n      }\n      return true;\n    }\n\n    return false;\n  } catch (_) {\n    return false;\n  }\n}\n\n// In case of any error on localStorage, we clean our own namespace, this should handle\n// quota errors when a lot of keys + data are used\nfunction cleanup() {\n  try {\n    global.localStorage.removeItem(localStorageNamespace);\n  } catch (_) {\n    // nothing to do\n  }\n}\n","var buildSearchMethod = require('./buildSearchMethod.js');\nvar deprecate = require('./deprecate.js');\nvar deprecatedMessage = require('./deprecatedMessage.js');\n\nmodule.exports = IndexCore;\n\n/*\n* Index class constructor.\n* You should not use this method directly but use initIndex() function\n*/\nfunction IndexCore(algoliasearch, indexName) {\n  this.indexName = indexName;\n  this.as = algoliasearch;\n  this.typeAheadArgs = null;\n  this.typeAheadValueOption = null;\n\n  // make sure every index instance has it's own cache\n  this.cache = {};\n}\n\n/*\n* Clear all queries in cache\n*/\nIndexCore.prototype.clearCache = function() {\n  this.cache = {};\n};\n\n/*\n* Search inside the index using XMLHttpRequest request (Using a POST query to\n* minimize number of OPTIONS queries: Cross-Origin Resource Sharing).\n*\n* @param {string} [query] the full text query\n* @param {object} [args] (optional) if set, contains an object with query parameters:\n* - page: (integer) Pagination parameter used to select the page to retrieve.\n*                   Page is zero-based and defaults to 0. Thus,\n*                   to retrieve the 10th page you need to set page=9\n* - hitsPerPage: (integer) Pagination parameter used to select the number of hits per page. Defaults to 20.\n* - attributesToRetrieve: a string that contains the list of object attributes\n* you want to retrieve (let you minimize the answer size).\n*   Attributes are separated with a comma (for example \"name,address\").\n*   You can also use an array (for example [\"name\",\"address\"]).\n*   By default, all attributes are retrieved. You can also use '*' to retrieve all\n*   values when an attributesToRetrieve setting is specified for your index.\n* - attributesToHighlight: a string that contains the list of attributes you\n*   want to highlight according to the query.\n*   Attributes are separated by a comma. You can also use an array (for example [\"name\",\"address\"]).\n*   If an attribute has no match for the query, the raw value is returned.\n*   By default all indexed text attributes are highlighted.\n*   You can use `*` if you want to highlight all textual attributes.\n*   Numerical attributes are not highlighted.\n*   A matchLevel is returned for each highlighted attribute and can contain:\n*      - full: if all the query terms were found in the attribute,\n*      - partial: if only some of the query terms were found,\n*      - none: if none of the query terms were found.\n* - attributesToSnippet: a string that contains the list of attributes to snippet alongside\n* the number of words to return (syntax is `attributeName:nbWords`).\n*    Attributes are separated by a comma (Example: attributesToSnippet=name:10,content:10).\n*    You can also use an array (Example: attributesToSnippet: ['name:10','content:10']).\n*    By default no snippet is computed.\n* - minWordSizefor1Typo: the minimum number of characters in a query word to accept one typo in this word.\n* Defaults to 3.\n* - minWordSizefor2Typos: the minimum number of characters in a query word\n* to accept two typos in this word. Defaults to 7.\n* - getRankingInfo: if set to 1, the result hits will contain ranking\n* information in _rankingInfo attribute.\n* - aroundLatLng: search for entries around a given\n* latitude/longitude (specified as two floats separated by a comma).\n*   For example aroundLatLng=47.316669,5.016670).\n*   You can specify the maximum distance in meters with the aroundRadius parameter (in meters)\n*   and the precision for ranking with aroundPrecision\n*   (for example if you set aroundPrecision=100, two objects that are distant of\n*   less than 100m will be considered as identical for \"geo\" ranking parameter).\n*   At indexing, you should specify geoloc of an object with the _geoloc attribute\n*   (in the form {\"_geoloc\":{\"lat\":48.853409, \"lng\":2.348800}})\n* - insideBoundingBox: search entries inside a given area defined by the two extreme points\n* of a rectangle (defined by 4 floats: p1Lat,p1Lng,p2Lat,p2Lng).\n*   For example insideBoundingBox=47.3165,4.9665,47.3424,5.0201).\n*   At indexing, you should specify geoloc of an object with the _geoloc attribute\n*   (in the form {\"_geoloc\":{\"lat\":48.853409, \"lng\":2.348800}})\n* - numericFilters: a string that contains the list of numeric filters you want to\n* apply separated by a comma.\n*   The syntax of one filter is `attributeName` followed by `operand` followed by `value`.\n*   Supported operands are `<`, `<=`, `=`, `>` and `>=`.\n*   You can have multiple conditions on one attribute like for example numericFilters=price>100,price<1000.\n*   You can also use an array (for example numericFilters: [\"price>100\",\"price<1000\"]).\n* - tagFilters: filter the query by a set of tags. You can AND tags by separating them by commas.\n*   To OR tags, you must add parentheses. For example, tags=tag1,(tag2,tag3) means tag1 AND (tag2 OR tag3).\n*   You can also use an array, for example tagFilters: [\"tag1\",[\"tag2\",\"tag3\"]]\n*   means tag1 AND (tag2 OR tag3).\n*   At indexing, tags should be added in the _tags** attribute\n*   of objects (for example {\"_tags\":[\"tag1\",\"tag2\"]}).\n* - facetFilters: filter the query by a list of facets.\n*   Facets are separated by commas and each facet is encoded as `attributeName:value`.\n*   For example: `facetFilters=category:Book,author:John%20Doe`.\n*   You can also use an array (for example `[\"category:Book\",\"author:John%20Doe\"]`).\n* - facets: List of object attributes that you want to use for faceting.\n*   Comma separated list: `\"category,author\"` or array `['category','author']`\n*   Only attributes that have been added in **attributesForFaceting** index setting\n*   can be used in this parameter.\n*   You can also use `*` to perform faceting on all attributes specified in **attributesForFaceting**.\n* - queryType: select how the query words are interpreted, it can be one of the following value:\n*    - prefixAll: all query words are interpreted as prefixes,\n*    - prefixLast: only the last word is interpreted as a prefix (default behavior),\n*    - prefixNone: no query word is interpreted as a prefix. This option is not recommended.\n* - optionalWords: a string that contains the list of words that should\n* be considered as optional when found in the query.\n*   Comma separated and array are accepted.\n* - distinct: If set to 1, enable the distinct feature (disabled by default)\n* if the attributeForDistinct index setting is set.\n*   This feature is similar to the SQL \"distinct\" keyword: when enabled\n*   in a query with the distinct=1 parameter,\n*   all hits containing a duplicate value for the attributeForDistinct attribute are removed from results.\n*   For example, if the chosen attribute is show_name and several hits have\n*   the same value for show_name, then only the best\n*   one is kept and others are removed.\n* - restrictSearchableAttributes: List of attributes you want to use for\n* textual search (must be a subset of the attributesToIndex index setting)\n* either comma separated or as an array\n* @param {function} [callback] the result callback called with two arguments:\n*  error: null or Error('message'). If false, the content contains the error.\n*  content: the server answer that contains the list of results.\n*/\nIndexCore.prototype.search = buildSearchMethod('query');\n\n/*\n* -- BETA --\n* Search a record similar to the query inside the index using XMLHttpRequest request (Using a POST query to\n* minimize number of OPTIONS queries: Cross-Origin Resource Sharing).\n*\n* @param {string} [query] the similar query\n* @param {object} [args] (optional) if set, contains an object with query parameters.\n*   All search parameters are supported (see search function), restrictSearchableAttributes and facetFilters\n*   are the two most useful to restrict the similar results and get more relevant content\n*/\nIndexCore.prototype.similarSearch = deprecate(\n  buildSearchMethod('similarQuery'),\n  deprecatedMessage(\n    'index.similarSearch(query[, callback])',\n    'index.search({ similarQuery: query }[, callback])'\n  )\n);\n\n/*\n* Browse index content. The response content will have a `cursor` property that you can use\n* to browse subsequent pages for this query. Use `index.browseFrom(cursor)` when you want.\n*\n* @param {string} query - The full text query\n* @param {Object} [queryParameters] - Any search query parameter\n* @param {Function} [callback] - The result callback called with two arguments\n*   error: null or Error('message')\n*   content: the server answer with the browse result\n* @return {Promise|undefined} Returns a promise if no callback given\n* @example\n* index.browse('cool songs', {\n*   tagFilters: 'public,comments',\n*   hitsPerPage: 500\n* }, callback);\n* @see {@link https://www.algolia.com/doc/rest_api#Browse|Algolia REST API Documentation}\n*/\nIndexCore.prototype.browse = function(query, queryParameters, callback) {\n  var merge = require('./merge.js');\n\n  var indexObj = this;\n\n  var page;\n  var hitsPerPage;\n\n  // we check variadic calls that are not the one defined\n  // .browse()/.browse(fn)\n  // => page = 0\n  if (arguments.length === 0 || arguments.length === 1 && typeof arguments[0] === 'function') {\n    page = 0;\n    callback = arguments[0];\n    query = undefined;\n  } else if (typeof arguments[0] === 'number') {\n    // .browse(2)/.browse(2, 10)/.browse(2, fn)/.browse(2, 10, fn)\n    page = arguments[0];\n    if (typeof arguments[1] === 'number') {\n      hitsPerPage = arguments[1];\n    } else if (typeof arguments[1] === 'function') {\n      callback = arguments[1];\n      hitsPerPage = undefined;\n    }\n    query = undefined;\n    queryParameters = undefined;\n  } else if (typeof arguments[0] === 'object') {\n    // .browse(queryParameters)/.browse(queryParameters, cb)\n    if (typeof arguments[1] === 'function') {\n      callback = arguments[1];\n    }\n    queryParameters = arguments[0];\n    query = undefined;\n  } else if (typeof arguments[0] === 'string' && typeof arguments[1] === 'function') {\n    // .browse(query, cb)\n    callback = arguments[1];\n    queryParameters = undefined;\n  }\n\n  // otherwise it's a .browse(query)/.browse(query, queryParameters)/.browse(query, queryParameters, cb)\n\n  // get search query parameters combining various possible calls\n  // to .browse();\n  queryParameters = merge({}, queryParameters || {}, {\n    page: page,\n    hitsPerPage: hitsPerPage,\n    query: query\n  });\n\n  var params = this.as._getSearchParams(queryParameters, '');\n\n  return this.as._jsonRequest({\n    method: 'POST',\n    url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/browse',\n    body: {params: params},\n    hostType: 'read',\n    callback: callback\n  });\n};\n\n/*\n* Continue browsing from a previous position (cursor), obtained via a call to `.browse()`.\n*\n* @param {string} query - The full text query\n* @param {Object} [queryParameters] - Any search query parameter\n* @param {Function} [callback] - The result callback called with two arguments\n*   error: null or Error('message')\n*   content: the server answer with the browse result\n* @return {Promise|undefined} Returns a promise if no callback given\n* @example\n* index.browseFrom('14lkfsakl32', callback);\n* @see {@link https://www.algolia.com/doc/rest_api#Browse|Algolia REST API Documentation}\n*/\nIndexCore.prototype.browseFrom = function(cursor, callback) {\n  return this.as._jsonRequest({\n    method: 'POST',\n    url: '/1/indexes/' + encodeURIComponent(this.indexName) + '/browse',\n    body: {cursor: cursor},\n    hostType: 'read',\n    callback: callback\n  });\n};\n\n/*\n* Search for facet values\n* https://www.algolia.com/doc/rest-api/search#search-for-facet-values\n*\n* @param {string} params.facetName Facet name, name of the attribute to search for values in.\n* Must be declared as a facet\n* @param {string} params.facetQuery Query for the facet search\n* @param {string} [params.*] Any search parameter of Algolia,\n* see https://www.algolia.com/doc/api-client/javascript/search#search-parameters\n* Pagination is not supported. The page and hitsPerPage parameters will be ignored.\n* @param callback (optional)\n*/\nIndexCore.prototype.searchForFacetValues = function(params, callback) {\n  var clone = require('./clone.js');\n  var omit = require('./omit.js');\n  var usage = 'Usage: index.searchForFacetValues({facetName, facetQuery, ...params}[, callback])';\n\n  if (params.facetName === undefined || params.facetQuery === undefined) {\n    throw new Error(usage);\n  }\n\n  var facetName = params.facetName;\n  var filteredParams = omit(clone(params), function(keyName) {\n    return keyName === 'facetName';\n  });\n  var searchParameters = this.as._getSearchParams(filteredParams, '');\n\n  return this.as._jsonRequest({\n    method: 'POST',\n    url: '/1/indexes/' +\n      encodeURIComponent(this.indexName) + '/facets/' + encodeURIComponent(facetName) + '/query',\n    hostType: 'read',\n    body: {params: searchParameters},\n    callback: callback\n  });\n};\n\nIndexCore.prototype.searchFacet = deprecate(function(params, callback) {\n  return this.searchForFacetValues(params, callback);\n}, deprecatedMessage(\n  'index.searchFacet(params[, callback])',\n  'index.searchForFacetValues(params[, callback])'\n));\n\nIndexCore.prototype._search = function(params, url, callback, additionalUA) {\n  return this.as._jsonRequest({\n    cache: this.cache,\n    method: 'POST',\n    url: url || '/1/indexes/' + encodeURIComponent(this.indexName) + '/query',\n    body: {params: params},\n    hostType: 'read',\n    fallback: {\n      method: 'GET',\n      url: '/1/indexes/' + encodeURIComponent(this.indexName),\n      body: {params: params}\n    },\n    callback: callback,\n    additionalUA: additionalUA\n  });\n};\n\n/*\n* Get an object from this index\n*\n* @param objectID the unique identifier of the object to retrieve\n* @param attrs (optional) if set, contains the array of attribute names to retrieve\n* @param callback (optional) the result callback called with two arguments\n*  error: null or Error('message')\n*  content: the object to retrieve or the error message if a failure occured\n*/\nIndexCore.prototype.getObject = function(objectID, attrs, callback) {\n  var indexObj = this;\n\n  if (arguments.length === 1 || typeof attrs === 'function') {\n    callback = attrs;\n    attrs = undefined;\n  }\n\n  var params = '';\n  if (attrs !== undefined) {\n    params = '?attributes=';\n    for (var i = 0; i < attrs.length; ++i) {\n      if (i !== 0) {\n        params += ',';\n      }\n      params += attrs[i];\n    }\n  }\n\n  return this.as._jsonRequest({\n    method: 'GET',\n    url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(objectID) + params,\n    hostType: 'read',\n    callback: callback\n  });\n};\n\n/*\n* Get several objects from this index\n*\n* @param objectIDs the array of unique identifier of objects to retrieve\n*/\nIndexCore.prototype.getObjects = function(objectIDs, attributesToRetrieve, callback) {\n  var isArray = require('isarray');\n  var map = require('./map.js');\n\n  var usage = 'Usage: index.getObjects(arrayOfObjectIDs[, callback])';\n\n  if (!isArray(objectIDs)) {\n    throw new Error(usage);\n  }\n\n  var indexObj = this;\n\n  if (arguments.length === 1 || typeof attributesToRetrieve === 'function') {\n    callback = attributesToRetrieve;\n    attributesToRetrieve = undefined;\n  }\n\n  var body = {\n    requests: map(objectIDs, function prepareRequest(objectID) {\n      var request = {\n        indexName: indexObj.indexName,\n        objectID: objectID\n      };\n\n      if (attributesToRetrieve) {\n        request.attributesToRetrieve = attributesToRetrieve.join(',');\n      }\n\n      return request;\n    })\n  };\n\n  return this.as._jsonRequest({\n    method: 'POST',\n    url: '/1/indexes/*/objects',\n    hostType: 'read',\n    body: body,\n    callback: callback\n  });\n};\n\nIndexCore.prototype.as = null;\nIndexCore.prototype.indexName = null;\nIndexCore.prototype.typeAheadArgs = null;\nIndexCore.prototype.typeAheadValueOption = null;\n","'use strict';\n\n/**\n * Module containing the functions to serialize and deserialize\n * {SearchParameters} in the query string format\n * @module algoliasearchHelper.url\n */\n\nvar shortener = require('./SearchParameters/shortener');\nvar SearchParameters = require('./SearchParameters');\n\nvar qs = require('qs');\n\nvar bind = require('lodash/bind');\nvar forEach = require('lodash/forEach');\nvar pick = require('lodash/pick');\nvar map = require('lodash/map');\nvar mapKeys = require('lodash/mapKeys');\nvar mapValues = require('lodash/mapValues');\nvar isString = require('lodash/isString');\nvar isPlainObject = require('lodash/isPlainObject');\nvar isEmpty = require('lodash/isEmpty');\nvar invert = require('lodash/invert');\n\nvar encode = require('qs/lib/utils').encode;\n\nfunction recursiveEncode(input) {\n  if (isPlainObject(input)) {\n    return mapValues(input, recursiveEncode);\n  }\n  if (Array.isArray(input)) {\n    return map(input, recursiveEncode);\n  }\n  if (isString(input)) {\n    return encode(input);\n  }\n  return input;\n}\n\nvar refinementsParameters = ['dFR', 'fR', 'nR', 'hFR', 'tR'];\nvar stateKeys = shortener.ENCODED_PARAMETERS;\nfunction sortQueryStringValues(prefixRegexp, invertedMapping, a, b) {\n  if (prefixRegexp !== null) {\n    a = a.replace(prefixRegexp, '');\n    b = b.replace(prefixRegexp, '');\n  }\n\n  a = invertedMapping[a] || a;\n  b = invertedMapping[b] || b;\n\n  if (stateKeys.indexOf(a) !== -1 || stateKeys.indexOf(b) !== -1) {\n    if (a === 'q') return -1;\n    if (b === 'q') return 1;\n\n    var isARefinements = refinementsParameters.indexOf(a) !== -1;\n    var isBRefinements = refinementsParameters.indexOf(b) !== -1;\n    if (isARefinements && !isBRefinements) {\n      return 1;\n    } else if (isBRefinements && !isARefinements) {\n      return -1;\n    }\n  }\n\n  return a.localeCompare(b);\n}\n\n/**\n * Read a query string and return an object containing the state\n * @param {string} queryString the query string that will be decoded\n * @param {object} [options] accepted options :\n *   - prefix : the prefix used for the saved attributes, you have to provide the\n *     same that was used for serialization\n *   - mapping : map short attributes to another value e.g. {q: 'query'}\n * @return {object} partial search parameters object (same properties than in the\n * SearchParameters but not exhaustive)\n */\nexports.getStateFromQueryString = function(queryString, options) {\n  var prefixForParameters = options && options.prefix || '';\n  var mapping = options && options.mapping || {};\n  var invertedMapping = invert(mapping);\n\n  var partialStateWithPrefix = qs.parse(queryString);\n  var prefixRegexp = new RegExp('^' + prefixForParameters);\n  var partialState = mapKeys(\n    partialStateWithPrefix,\n    function(v, k) {\n      var hasPrefix = prefixForParameters && prefixRegexp.test(k);\n      var unprefixedKey = hasPrefix ? k.replace(prefixRegexp, '') : k;\n      var decodedKey = shortener.decode(invertedMapping[unprefixedKey] || unprefixedKey);\n      return decodedKey || unprefixedKey;\n    }\n  );\n\n  var partialStateWithParsedNumbers = SearchParameters._parseNumbers(partialState);\n\n  return pick(partialStateWithParsedNumbers, SearchParameters.PARAMETERS);\n};\n\n/**\n * Retrieve an object of all the properties that are not understandable as helper\n * parameters.\n * @param {string} queryString the query string to read\n * @param {object} [options] the options\n *   - prefixForParameters : prefix used for the helper configuration keys\n *   - mapping : map short attributes to another value e.g. {q: 'query'}\n * @return {object} the object containing the parsed configuration that doesn't\n * to the helper\n */\nexports.getUnrecognizedParametersInQueryString = function(queryString, options) {\n  var prefixForParameters = options && options.prefix;\n  var mapping = options && options.mapping || {};\n  var invertedMapping = invert(mapping);\n\n  var foreignConfig = {};\n  var config = qs.parse(queryString);\n  if (prefixForParameters) {\n    var prefixRegexp = new RegExp('^' + prefixForParameters);\n    forEach(config, function(v, key) {\n      if (!prefixRegexp.test(key)) foreignConfig[key] = v;\n    });\n  } else {\n    forEach(config, function(v, key) {\n      if (!shortener.decode(invertedMapping[key] || key)) foreignConfig[key] = v;\n    });\n  }\n\n  return foreignConfig;\n};\n\n/**\n * Generate a query string for the state passed according to the options\n * @param {SearchParameters} state state to serialize\n * @param {object} [options] May contain the following parameters :\n *  - prefix : prefix in front of the keys\n *  - mapping : map short attributes to another value e.g. {q: 'query'}\n *  - moreAttributes : more values to be added in the query string. Those values\n *    won't be prefixed.\n *  - safe : get safe urls for use in emails, chat apps or any application auto linking urls.\n *  All parameters and values will be encoded in a way that it's safe to share them.\n *  Default to false for legacy reasons ()\n * @return {string} the query string\n */\nexports.getQueryStringFromState = function(state, options) {\n  var moreAttributes = options && options.moreAttributes;\n  var prefixForParameters = options && options.prefix || '';\n  var mapping = options && options.mapping || {};\n  var safe = options && options.safe || false;\n  var invertedMapping = invert(mapping);\n\n  var stateForUrl = safe ? state : recursiveEncode(state);\n\n  var encodedState = mapKeys(\n    stateForUrl,\n    function(v, k) {\n      var shortK = shortener.encode(k);\n      return prefixForParameters + (mapping[shortK] || shortK);\n    }\n  );\n\n  var prefixRegexp = prefixForParameters === '' ? null : new RegExp('^' + prefixForParameters);\n  var sort = bind(sortQueryStringValues, null, prefixRegexp, invertedMapping);\n  if (!isEmpty(moreAttributes)) {\n    var stateQs = qs.stringify(encodedState, {encode: safe, sort: sort});\n    var moreQs = qs.stringify(moreAttributes, {encode: safe});\n    if (!stateQs) return moreQs;\n    return stateQs + '&' + moreQs;\n  }\n\n  return qs.stringify(encodedState, {encode: safe, sort: sort});\n};\n","'use strict';\n\nmodule.exports = generateTrees;\n\nvar last = require('lodash/last');\nvar map = require('lodash/map');\nvar reduce = require('lodash/reduce');\nvar orderBy = require('lodash/orderBy');\nvar trim = require('lodash/trim');\nvar find = require('lodash/find');\nvar pickBy = require('lodash/pickBy');\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] &&\n      state.hierarchicalFacetsRefinements[hierarchicalFacet.name][0] || '';\n    var hierarchicalSeparator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n    var hierarchicalRootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n    var hierarchicalShowParentLevel = state._getHierarchicalShowParentLevel(hierarchicalFacet);\n    var sortBy = prepareHierarchicalFacetSortBy(state._getHierarchicalFacetSortBy(hierarchicalFacet));\n\n    var generateTreeFn = generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath,\n      hierarchicalShowParentLevel, hierarchicalFacetRefinement);\n\n    var results = hierarchicalFacetResult;\n\n    if (hierarchicalRootPath) {\n      results = hierarchicalFacetResult.slice(hierarchicalRootPath.split(hierarchicalSeparator).length);\n    }\n\n    return reduce(results, generateTreeFn, {\n      name: state.hierarchicalFacets[hierarchicalFacetIndex].name,\n      count: null, // root level, no count\n      isRefined: true, // root level, always refined\n      path: null, // root level, no path\n      data: null\n    });\n  };\n}\n\nfunction generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath,\n                                  hierarchicalShowParentLevel, currentRefinement) {\n  return function generateTree(hierarchicalTree, hierarchicalFacetResult, currentHierarchicalLevel) {\n    var parent = hierarchicalTree;\n\n    if (currentHierarchicalLevel > 0) {\n      var level = 0;\n\n      parent = hierarchicalTree;\n\n      while (level < currentHierarchicalLevel) {\n        parent = parent && find(parent.data, {isRefined: true});\n        level++;\n      }\n    }\n\n    // we found a refined parent, let's add current level data under it\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\n      var onlyMatchingValuesFn = filterFacetValues(parent.path || hierarchicalRootPath,\n        currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel);\n\n      parent.data = orderBy(\n        map(\n          pickBy(hierarchicalFacetResult.data, onlyMatchingValuesFn),\n          formatHierarchicalFacetValue(hierarchicalSeparator, currentRefinement)\n        ),\n        sortBy[0], sortBy[1]\n      );\n    }\n\n    return hierarchicalTree;\n  };\n}\n\nfunction filterFacetValues(parentPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath,\n                           hierarchicalShowParentLevel) {\n  return function(facetCount, facetValue) {\n    // we want the facetValue is a child of hierarchicalRootPath\n    if (hierarchicalRootPath &&\n      (facetValue.indexOf(hierarchicalRootPath) !== 0 || hierarchicalRootPath === facetValue)) {\n      return false;\n    }\n\n    // we always want root levels (only when there is no prefix path)\n    return !hierarchicalRootPath && facetValue.indexOf(hierarchicalSeparator) === -1 ||\n      // if there is a rootPath, being root level mean 1 level under rootPath\n      hierarchicalRootPath &&\n      facetValue.split(hierarchicalSeparator).length - hierarchicalRootPath.split(hierarchicalSeparator).length === 1 ||\n      // if current refinement is a root level and current facetValue is a root level,\n      // keep the facetValue\n      facetValue.indexOf(hierarchicalSeparator) === -1 &&\n      currentRefinement.indexOf(hierarchicalSeparator) === -1 ||\n      // currentRefinement is a child of the facet value\n      currentRefinement.indexOf(facetValue) === 0 ||\n      // facetValue is a child of the current parent, add it\n      facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 &&\n      (hierarchicalShowParentLevel || facetValue.indexOf(currentRefinement) === 0);\n  };\n}\n\nfunction formatHierarchicalFacetValue(hierarchicalSeparator, currentRefinement) {\n  return function format(facetCount, facetValue) {\n    return {\n      name: trim(last(facetValue.split(hierarchicalSeparator))),\n      path: facetValue,\n      count: facetCount,\n      isRefined: currentRefinement === facetValue || currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,\n      data: null\n    };\n  };\n}\n","module.exports = function deprecate(fn, message) {\n  var warned = false;\n\n  function deprecated() {\n    if (!warned) {\n      /* eslint no-console:0 */\n      console.warn(message);\n      warned = true;\n    }\n\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n","'use strict';\n\nvar map = require('lodash/map');\nvar isNumber = require('lodash/isNumber');\nvar isString = require('lodash/isString');\nfunction valToNumber(v) {\n  if (isNumber(v)) {\n    return v;\n  } else if (isString(v)) {\n    return parseFloat(v);\n  } else if (Array.isArray(v)) {\n    return map(v, valToNumber);\n  }\n\n  throw new Error('The value should be a number, a parseable string or an array of those.');\n}\n\nmodule.exports = valToNumber;\n","module.exports = function clone(obj) {\n  return JSON.parse(JSON.stringify(obj));\n};\n","'use strict';\n\nvar forEach = require('lodash/forEach');\nvar compact = require('lodash/compact');\nvar indexOf = require('lodash/indexOf');\nvar findIndex = require('lodash/findIndex');\nvar get = require('lodash/get');\n\nvar sumBy = require('lodash/sumBy');\nvar find = require('lodash/find');\nvar includes = require('lodash/includes');\nvar map = require('lodash/map');\nvar orderBy = require('lodash/orderBy');\n\nvar defaults = require('lodash/defaults');\nvar merge = require('lodash/merge');\n\nvar isFunction = require('lodash/isFunction');\n\nvar partial = require('lodash/partial');\nvar partialRight = require('lodash/partialRight');\n\nvar formatSort = require('../functions/formatSort');\n\nvar generateHierarchicalTree = require('./generate-hierarchical-tree');\n\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\nfunction getIndices(obj) {\n  var indices = {};\n\n  forEach(obj, function(val, idx) { 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\nfunction findMatchingHierarchicalFacetFromAttributeName(hierarchicalFacets, hierarchicalAttributeName) {\n  return find(\n    hierarchicalFacets,\n    function facetKeyMatchesAttribute(hierarchicalFacet) {\n      return includes(hierarchicalFacet.attributes, hierarchicalAttributeName);\n    }\n  );\n}\n\n/*eslint-disable */\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/*eslint-enable */\nfunction SearchResults(state, results) {\n  var mainSubResponse = results[0];\n\n  this._rawResults = results;\n\n  /**\n   * query used to generate the results\n   * @member {string}\n   */\n  this.query = mainSubResponse.query;\n  /**\n   * The query as parsed by the engine given all the rules.\n   * @member {string}\n   */\n  this.parsedQuery = mainSubResponse.parsedQuery;\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   * @member {object[]}\n   */\n  this.hits = mainSubResponse.hits;\n  /**\n   * index where the results come from\n   * @member {string}\n   */\n  this.index = mainSubResponse.index;\n  /**\n   * number of hits per page requested\n   * @member {number}\n   */\n  this.hitsPerPage = mainSubResponse.hitsPerPage;\n  /**\n   * total number of hits of this query on the index\n   * @member {number}\n   */\n  this.nbHits = mainSubResponse.nbHits;\n  /**\n   * total number of pages with respect to the number of hits per page and the total number of hits\n   * @member {number}\n   */\n  this.nbPages = mainSubResponse.nbPages;\n  /**\n   * current page\n   * @member {number}\n   */\n  this.page = mainSubResponse.page;\n  /**\n   * sum of the processing time of all the queries\n   * @member {number}\n   */\n  this.processingTimeMS = sumBy(results, 'processingTimeMS');\n  /**\n   * The position if the position was guessed by IP.\n   * @member {string}\n   * @example \"48.8637,2.3615\",\n   */\n  this.aroundLatLng = mainSubResponse.aroundLatLng;\n  /**\n   * The radius computed by Algolia.\n   * @member {string}\n   * @example \"126792922\",\n   */\n  this.automaticRadius = mainSubResponse.automaticRadius;\n  /**\n   * String identifying the server used to serve this request.\n   * @member {string}\n   * @example \"c7-use-2.algolia.net\",\n   */\n  this.serverUsed = mainSubResponse.serverUsed;\n  /**\n   * Boolean that indicates if the computation of the counts did time out.\n   * @deprecated\n   * @member {boolean}\n   */\n  this.timeoutCounts = mainSubResponse.timeoutCounts;\n  /**\n   * Boolean that indicates if the computation of the hits did time out.\n   * @deprecated\n   * @member {boolean}\n   */\n  this.timeoutHits = mainSubResponse.timeoutHits;\n\n  /**\n   * True if the counts of the facets is exhaustive\n   * @member {boolean}\n   */\n  this.exhaustiveFacetsCount = mainSubResponse.exhaustiveFacetsCount;\n\n  /**\n   * True if the number of hits is exhaustive\n   * @member {boolean}\n   */\n  this.exhaustiveNbHits = mainSubResponse.exhaustiveNbHits;\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   * @member {object[]}\n   */\n  this.userData = mainSubResponse.userData;\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   * @member {string}\n   */\n  this.queryID = mainSubResponse.queryID;\n\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.Facet[]}\n   */\n  this.disjunctiveFacets = [];\n  /**\n   * disjunctive facets results\n   * @member {SearchResults.HierarchicalFacet[]}\n   */\n  this.hierarchicalFacets = map(state.hierarchicalFacets, function initFutureTree() {\n    return [];\n  });\n  /**\n   * other facets results\n   * @member {SearchResults.Facet[]}\n   */\n  this.facets = [];\n\n  var disjunctiveFacets = state.getRefinedDisjunctiveFacets();\n\n  var facetsIndices = getIndices(state.facets);\n  var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);\n  var nextDisjunctiveResult = 1;\n\n  var self = this;\n  // Since we send request only for disjunctive facets that have been refined,\n  // we get the facets informations from the first, general, response.\n  forEach(mainSubResponse.facets, function(facetValueObject, facetKey) {\n    var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(\n      state.hierarchicalFacets,\n      facetKey\n    );\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, {name: hierarchicalFacet.name});\n      self.hierarchicalFacets[idxAttributeName][facetIndex] = {\n        attribute: facetKey,\n        data: facetValueObject,\n        exhaustive: mainSubResponse.exhaustiveFacetsCount\n      };\n    } else {\n      var isFacetDisjunctive = indexOf(state.disjunctiveFacets, facetKey) !== -1;\n      var isFacetConjunctive = indexOf(state.facets, 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      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  });\n\n  // Make sure we do not keep holes within the hierarchical facets\n  this.hierarchicalFacets = compact(this.hierarchicalFacets);\n\n  // aggregate the refined disjunctive facets\n  forEach(disjunctiveFacets, function(disjunctiveFacet) {\n    var result = results[nextDisjunctiveResult];\n    var hierarchicalFacet = state.getHierarchicalFacetByName(disjunctiveFacet);\n\n    // There should be only item in facets.\n    forEach(result.facets, function(facetResults, dfacet) {\n      var position;\n\n      if (hierarchicalFacet) {\n        position = findIndex(state.hierarchicalFacets, {name: hierarchicalFacet.name});\n        var attributeIndex = findIndex(self.hierarchicalFacets[position], {attribute: dfacet});\n\n        // previous refinements and no results so not able to find it\n        if (attributeIndex === -1) {\n          return;\n        }\n\n        self.hierarchicalFacets[position][attributeIndex].data = merge(\n          {},\n          self.hierarchicalFacets[position][attributeIndex].data,\n          facetResults\n        );\n      } else {\n        position = disjunctiveFacetsIndices[dfacet];\n\n        var dataFromMainRequest = mainSubResponse.facets && mainSubResponse.facets[dfacet] || {};\n\n        self.disjunctiveFacets[position] = {\n          name: dfacet,\n          data: defaults({}, facetResults, dataFromMainRequest),\n          exhaustive: result.exhaustiveFacetsCount\n        };\n        assignFacetStats(self.disjunctiveFacets[position], result.facets_stats, dfacet);\n\n        if (state.disjunctiveFacetsRefinements[dfacet]) {\n          forEach(state.disjunctiveFacetsRefinements[dfacet], function(refinementValue) {\n            // add the disjunctive refinements if it is no more retrieved\n            if (!self.disjunctiveFacets[position].data[refinementValue] &&\n              indexOf(state.disjunctiveFacetsRefinements[dfacet], refinementValue) > -1) {\n              self.disjunctiveFacets[position].data[refinementValue] = 0;\n            }\n          });\n        }\n      }\n    });\n    nextDisjunctiveResult++;\n  });\n\n  // if we have some root level values for hierarchical facets, merge them\n  forEach(state.getRefinedHierarchicalFacets(), function(refinedFacet) {\n    var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n\n    var currentRefinement = state.getHierarchicalRefinement(refinedFacet);\n    // if we are already at a root refinement (or no refinement at all), there is no\n    // root level values request\n    if (currentRefinement.length === 0 || currentRefinement[0].split(separator).length < 2) {\n      return;\n    }\n\n    var result = results[nextDisjunctiveResult];\n\n    forEach(result.facets, function(facetResults, dfacet) {\n      var position = findIndex(state.hierarchicalFacets, {name: hierarchicalFacet.name});\n      var attributeIndex = findIndex(self.hierarchicalFacets[position], {attribute: dfacet});\n\n      // previous refinements and no results so not able to find it\n      if (attributeIndex === -1) {\n        return;\n      }\n\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      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 = defaults(\n        defaultData,\n        facetResults,\n        self.hierarchicalFacets[position][attributeIndex].data\n      );\n    });\n\n    nextDisjunctiveResult++;\n  });\n\n  // add the excludes\n  forEach(state.facetsExcludes, function(excludes, facetName) {\n    var position = facetsIndices[facetName];\n\n    self.facets[position] = {\n      name: facetName,\n      data: mainSubResponse.facets[facetName],\n      exhaustive: mainSubResponse.exhaustiveFacetsCount\n    };\n    forEach(excludes, function(facetValue) {\n      self.facets[position] = self.facets[position] || {name: facetName};\n      self.facets[position].data = self.facets[position].data || {};\n      self.facets[position].data[facetValue] = 0;\n    });\n  });\n\n  this.hierarchicalFacets = map(this.hierarchicalFacets, generateHierarchicalTree(state));\n\n  this.facets = compact(this.facets);\n  this.disjunctiveFacets = compact(this.disjunctiveFacets);\n\n  this._state = state;\n}\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 */\nSearchResults.prototype.getFacetByName = function(name) {\n  var predicate = {name: name};\n\n  return find(this.facets, predicate) ||\n    find(this.disjunctiveFacets, predicate) ||\n    find(this.hierarchicalFacets, predicate);\n};\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 */\nfunction extractNormalizedFacetValues(results, attribute) {\n  var predicate = {name: attribute};\n  if (results._state.isConjunctiveFacet(attribute)) {\n    var facet = find(results.facets, predicate);\n    if (!facet) return [];\n\n    return map(facet.data, function(v, k) {\n      return {\n        name: k,\n        count: v,\n        isRefined: results._state.isFacetRefined(attribute, k),\n        isExcluded: results._state.isExcludeRefined(attribute, k)\n      };\n    });\n  } else if (results._state.isDisjunctiveFacet(attribute)) {\n    var disjunctiveFacet = find(results.disjunctiveFacets, predicate);\n    if (!disjunctiveFacet) return [];\n\n    return map(disjunctiveFacet.data, function(v, k) {\n      return {\n        name: k,\n        count: v,\n        isRefined: results._state.isDisjunctiveFacetRefined(attribute, k)\n      };\n    });\n  } else if (results._state.isHierarchicalFacet(attribute)) {\n    return find(results.hierarchicalFacets, predicate);\n  }\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 */\nfunction recSort(sortFn, node) {\n  if (!node.data || node.data.length === 0) {\n    return node;\n  }\n  var children = map(node.data, partial(recSort, sortFn));\n  var sortedChildren = sortFn(children);\n  var newNode = merge({}, node, {data: sortedChildren});\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/**\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} depending on the type of facet of\n * the attribute requested (hierarchical, disjunctive or conjunctive)\n * @example\n * helper.on('results', function(content){\n *   //get values ordered only by name ascending using the string predicate\n *   content.getFacetValues('city', {sortBy: ['name:asc']});\n *   //get values  ordered only by count ascending using a function\n *   content.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 */\nSearchResults.prototype.getFacetValues = function(attribute, opts) {\n  var facetValues = extractNormalizedFacetValues(this, attribute);\n  if (!facetValues) throw new Error(attribute + ' is not a retrieved facet.');\n\n  var options = defaults({}, opts, {sortBy: SearchResults.DEFAULT_SORT});\n\n  if (Array.isArray(options.sortBy)) {\n    var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);\n    if (Array.isArray(facetValues)) {\n      return orderBy(facetValues, order[0], order[1]);\n    }\n    // If facetValues is not an array, it's an object thus a hierarchical facet object\n    return recSort(partialRight(orderBy, order[0], order[1]), facetValues);\n  } else if (isFunction(options.sortBy)) {\n    if (Array.isArray(facetValues)) {\n      return facetValues.sort(options.sortBy);\n    }\n    // If facetValues is not an array, it's an object thus a hierarchical facet object\n    return recSort(partial(vanillaSortFn, options.sortBy), facetValues);\n  }\n  throw new Error(\n    'options.sortBy is optional but if defined it must be ' +\n    'either an array of string (predicates) or a sorting function'\n  );\n};\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 */\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  throw new Error(attribute + ' is not present in `facets` or `disjunctiveFacets`');\n};\n\nfunction getFacetStatsIfAvailable(facetList, facetName) {\n  var data = find(facetList, {name: facetName});\n  return data && data.stats;\n}\n\n/**\n * Returns all refinements for all filters + tags. It also provides\n * additional information: count and exhausistivity for each filter.\n *\n * See the [refinement type](#Refinement) for an exhaustive view of the available\n * data.\n *\n * @return {Array.<Refinement>} all the refinements\n */\nSearchResults.prototype.getRefinements = function() {\n  var state = this._state;\n  var results = this;\n  var res = [];\n\n  forEach(state.facetsRefinements, function(refinements, attributeName) {\n    forEach(refinements, function(name) {\n      res.push(getRefinement(state, 'facet', attributeName, name, results.facets));\n    });\n  });\n\n  forEach(state.facetsExcludes, function(refinements, attributeName) {\n    forEach(refinements, function(name) {\n      res.push(getRefinement(state, 'exclude', attributeName, name, results.facets));\n    });\n  });\n\n  forEach(state.disjunctiveFacetsRefinements, function(refinements, attributeName) {\n    forEach(refinements, function(name) {\n      res.push(getRefinement(state, 'disjunctive', attributeName, name, results.disjunctiveFacets));\n    });\n  });\n\n  forEach(state.hierarchicalFacetsRefinements, function(refinements, attributeName) {\n    forEach(refinements, function(name) {\n      res.push(getHierarchicalRefinement(state, attributeName, name, results.hierarchicalFacets));\n    });\n  });\n\n  forEach(state.numericRefinements, function(operators, attributeName) {\n    forEach(operators, function(values, operator) {\n      forEach(values, 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\n  forEach(state.tagRefinements, function(name) {\n    res.push({type: 'tag', attributeName: '_tags', name: name});\n  });\n\n  return res;\n};\n\nfunction getRefinement(state, type, attributeName, name, resultsFacets) {\n  var facet = find(resultsFacets, {name: attributeName});\n  var count = get(facet, 'data[' + name + ']');\n  var exhaustive = get(facet, 'exhaustive');\n  return {\n    type: type,\n    attributeName: attributeName,\n    name: name,\n    count: count || 0,\n    exhaustive: exhaustive || false\n  };\n}\n\nfunction getHierarchicalRefinement(state, attributeName, name, resultsFacets) {\n  var facet = find(resultsFacets, {name: attributeName});\n  var facetDeclaration = state.getHierarchicalFacetByName(attributeName);\n  var splitted = name.split(facetDeclaration.separator);\n  var configuredName = splitted[splitted.length - 1];\n  for (var i = 0; facet !== undefined && i < splitted.length; ++i) {\n    facet = find(facet.data, {name: splitted[i]});\n  }\n  var count = get(facet, 'count');\n  var exhaustive = get(facet, 'exhaustive');\n  return {\n    type: 'hierarchical',\n    attributeName: attributeName,\n    name: configuredName,\n    count: count || 0,\n    exhaustive: exhaustive || false\n  };\n}\n\nmodule.exports = SearchResults;\n","'use strict';\n\nvar AlgoliaSearchCore = require('../../AlgoliaSearchCore.js');\nvar createAlgoliasearch = require('../createAlgoliasearch.js');\n\nmodule.exports = createAlgoliasearch(AlgoliaSearchCore, '(lite) ');\n","module.exports = AlgoliaSearchCore;\n\nvar errors = require('./errors');\nvar exitPromise = require('./exitPromise.js');\nvar IndexCore = require('./IndexCore.js');\nvar store = require('./store.js');\n\n// We will always put the API KEY in the JSON body in case of too long API KEY,\n// to avoid query string being too long and failing in various conditions (our server limit, browser limit,\n// proxies limit)\nvar MAX_API_KEY_LENGTH = 500;\nvar RESET_APP_DATA_TIMER =\n  process.env.RESET_APP_DATA_TIMER && parseInt(process.env.RESET_APP_DATA_TIMER, 10) ||\n  60 * 2 * 1000; // after 2 minutes reset to first host\n\n/*\n * Algolia Search library initialization\n * https://www.algolia.com/\n *\n * @param {string} applicationID - Your applicationID, found in your dashboard\n * @param {string} apiKey - Your API key, found in your dashboard\n * @param {Object} [opts]\n * @param {number} [opts.timeout=2000] - The request timeout set in milliseconds,\n * another request will be issued after this timeout\n * @param {string} [opts.protocol='https:'] - The protocol used to query Algolia Search API.\n *                                        Set to 'http:' to force using http.\n * @param {Object|Array} [opts.hosts={\n *           read: [this.applicationID + '-dsn.algolia.net'].concat([\n *             this.applicationID + '-1.algolianet.com',\n *             this.applicationID + '-2.algolianet.com',\n *             this.applicationID + '-3.algolianet.com']\n *           ]),\n *           write: [this.applicationID + '.algolia.net'].concat([\n *             this.applicationID + '-1.algolianet.com',\n *             this.applicationID + '-2.algolianet.com',\n *             this.applicationID + '-3.algolianet.com']\n *           ]) - The hosts to use for Algolia Search API.\n *           If you provide them, you will less benefit from our HA implementation\n */\nfunction AlgoliaSearchCore(applicationID, apiKey, opts) {\n  var debug = require('debug')('algoliasearch');\n\n  var clone = require('./clone.js');\n  var isArray = require('isarray');\n  var map = require('./map.js');\n\n  var usage = 'Usage: algoliasearch(applicationID, apiKey, opts)';\n\n  if (opts._allowEmptyCredentials !== true && !applicationID) {\n    throw new errors.AlgoliaSearchError('Please provide an application ID. ' + usage);\n  }\n\n  if (opts._allowEmptyCredentials !== true && !apiKey) {\n    throw new errors.AlgoliaSearchError('Please provide an API key. ' + usage);\n  }\n\n  this.applicationID = applicationID;\n  this.apiKey = apiKey;\n\n  this.hosts = {\n    read: [],\n    write: []\n  };\n\n  opts = opts || {};\n\n  this._timeouts = opts.timeouts || {\n    connect: 1 * 1000, // 500ms connect is GPRS latency\n    read: 2 * 1000,\n    write: 30 * 1000\n  };\n\n  // backward compat, if opts.timeout is passed, we use it to configure all timeouts like before\n  if (opts.timeout) {\n    this._timeouts.connect = this._timeouts.read = this._timeouts.write = opts.timeout;\n  }\n\n  var protocol = opts.protocol || 'https:';\n  // while we advocate for colon-at-the-end values: 'http:' for `opts.protocol`\n  // we also accept `http` and `https`. It's a common error.\n  if (!/:$/.test(protocol)) {\n    protocol = protocol + ':';\n  }\n\n  if (protocol !== 'http:' && protocol !== 'https:') {\n    throw new errors.AlgoliaSearchError('protocol must be `http:` or `https:` (was `' + opts.protocol + '`)');\n  }\n\n  this._checkAppIdData();\n\n  if (!opts.hosts) {\n    var defaultHosts = map(this._shuffleResult, function(hostNumber) {\n      return applicationID + '-' + hostNumber + '.algolianet.com';\n    });\n\n    // no hosts given, compute defaults\n    var mainSuffix = (opts.dsn === false ? '' : '-dsn') + '.algolia.net';\n    this.hosts.read = [this.applicationID + mainSuffix].concat(defaultHosts);\n    this.hosts.write = [this.applicationID + '.algolia.net'].concat(defaultHosts);\n  } else if (isArray(opts.hosts)) {\n    // when passing custom hosts, we need to have a different host index if the number\n    // of write/read hosts are different.\n    this.hosts.read = clone(opts.hosts);\n    this.hosts.write = clone(opts.hosts);\n  } else {\n    this.hosts.read = clone(opts.hosts.read);\n    this.hosts.write = clone(opts.hosts.write);\n  }\n\n  // add protocol and lowercase hosts\n  this.hosts.read = map(this.hosts.read, prepareHost(protocol));\n  this.hosts.write = map(this.hosts.write, prepareHost(protocol));\n\n  this.extraHeaders = {};\n\n  // In some situations you might want to warm the cache\n  this.cache = opts._cache || {};\n\n  this._ua = opts._ua;\n  this._useCache = opts._useCache === undefined || opts._cache ? true : opts._useCache;\n  this._useRequestCache = this._useCache && opts._useRequestCache;\n  this._useFallback = opts.useFallback === undefined ? true : opts.useFallback;\n\n  this._setTimeout = opts._setTimeout;\n\n  debug('init done, %j', this);\n}\n\n/*\n * Get the index object initialized\n *\n * @param indexName the name of index\n * @param callback the result callback with one argument (the Index instance)\n */\nAlgoliaSearchCore.prototype.initIndex = function(indexName) {\n  return new IndexCore(this, indexName);\n};\n\n/**\n* Add an extra field to the HTTP request\n*\n* @param name the header field name\n* @param value the header field value\n*/\nAlgoliaSearchCore.prototype.setExtraHeader = function(name, value) {\n  this.extraHeaders[name.toLowerCase()] = value;\n};\n\n/**\n* Get the value of an extra HTTP header\n*\n* @param name the header field name\n*/\nAlgoliaSearchCore.prototype.getExtraHeader = function(name) {\n  return this.extraHeaders[name.toLowerCase()];\n};\n\n/**\n* Remove an extra field from the HTTP request\n*\n* @param name the header field name\n*/\nAlgoliaSearchCore.prototype.unsetExtraHeader = function(name) {\n  delete this.extraHeaders[name.toLowerCase()];\n};\n\n/**\n* Augment sent x-algolia-agent with more data, each agent part\n* is automatically separated from the others by a semicolon;\n*\n* @param algoliaAgent the agent to add\n*/\nAlgoliaSearchCore.prototype.addAlgoliaAgent = function(algoliaAgent) {\n  if (this._ua.indexOf(';' + algoliaAgent) === -1) {\n    this._ua += ';' + algoliaAgent;\n  }\n};\n\n/*\n * Wrapper that try all hosts to maximize the quality of service\n */\nAlgoliaSearchCore.prototype._jsonRequest = function(initialOpts) {\n  this._checkAppIdData();\n\n  var requestDebug = require('debug')('algoliasearch:' + initialOpts.url);\n\n\n  var body;\n  var cacheID;\n  var additionalUA = initialOpts.additionalUA || '';\n  var cache = initialOpts.cache;\n  var client = this;\n  var tries = 0;\n  var usingFallback = false;\n  var hasFallback = client._useFallback && client._request.fallback && initialOpts.fallback;\n  var headers;\n\n  if (\n    this.apiKey.length > MAX_API_KEY_LENGTH &&\n    initialOpts.body !== undefined &&\n    (initialOpts.body.params !== undefined || // index.search()\n    initialOpts.body.requests !== undefined) // client.search()\n  ) {\n    initialOpts.body.apiKey = this.apiKey;\n    headers = this._computeRequestHeaders({\n      additionalUA: additionalUA,\n      withApiKey: false,\n      headers: initialOpts.headers\n    });\n  } else {\n    headers = this._computeRequestHeaders({\n      additionalUA: additionalUA,\n      headers: initialOpts.headers\n    });\n  }\n\n  if (initialOpts.body !== undefined) {\n    body = safeJSONStringify(initialOpts.body);\n  }\n\n  requestDebug('request start');\n  var debugData = [];\n\n\n  function doRequest(requester, reqOpts) {\n    client._checkAppIdData();\n\n    var startTime = new Date();\n\n    if (client._useCache && !client._useRequestCache) {\n      cacheID = initialOpts.url;\n    }\n\n    // as we sometime use POST requests to pass parameters (like query='aa'),\n    // the cacheID must also include the body to be different between calls\n    if (client._useCache && !client._useRequestCache && body) {\n      cacheID += '_body_' + reqOpts.body;\n    }\n\n    // handle cache existence\n    if (isCacheValidWithCurrentID(!client._useRequestCache, cache, cacheID)) {\n      requestDebug('serving response from cache');\n\n      var responseText = cache[cacheID];\n\n      // Cache response must match the type of the original one\n      return client._promise.resolve({\n        body: JSON.parse(responseText),\n        responseText: responseText\n      });\n    }\n\n    // if we reached max tries\n    if (tries >= client.hosts[initialOpts.hostType].length) {\n      if (!hasFallback || usingFallback) {\n        requestDebug('could not get any response');\n        // then stop\n        return client._promise.reject(new errors.AlgoliaSearchError(\n          'Cannot connect to the AlgoliaSearch API.' +\n          ' Send an email to support@algolia.com to report and resolve the issue.' +\n          ' Application id was: ' + client.applicationID, {debugData: debugData}\n        ));\n      }\n\n      requestDebug('switching to fallback');\n\n      // let's try the fallback starting from here\n      tries = 0;\n\n      // method, url and body are fallback dependent\n      reqOpts.method = initialOpts.fallback.method;\n      reqOpts.url = initialOpts.fallback.url;\n      reqOpts.jsonBody = initialOpts.fallback.body;\n      if (reqOpts.jsonBody) {\n        reqOpts.body = safeJSONStringify(reqOpts.jsonBody);\n      }\n      // re-compute headers, they could be omitting the API KEY\n      headers = client._computeRequestHeaders({\n        additionalUA: additionalUA,\n        headers: initialOpts.headers\n      });\n\n      reqOpts.timeouts = client._getTimeoutsForRequest(initialOpts.hostType);\n      client._setHostIndexByType(0, initialOpts.hostType);\n      usingFallback = true; // the current request is now using fallback\n      return doRequest(client._request.fallback, reqOpts);\n    }\n\n    var currentHost = client._getHostByType(initialOpts.hostType);\n\n    var url = currentHost + reqOpts.url;\n    var options = {\n      body: reqOpts.body,\n      jsonBody: reqOpts.jsonBody,\n      method: reqOpts.method,\n      headers: headers,\n      timeouts: reqOpts.timeouts,\n      debug: requestDebug,\n      forceAuthHeaders: reqOpts.forceAuthHeaders\n    };\n\n    requestDebug('method: %s, url: %s, headers: %j, timeouts: %d',\n      options.method, url, options.headers, options.timeouts);\n\n    if (requester === client._request.fallback) {\n      requestDebug('using fallback');\n    }\n\n    // `requester` is any of this._request or this._request.fallback\n    // thus it needs to be called using the client as context\n    return requester.call(client, url, options).then(success, tryFallback);\n\n    function success(httpResponse) {\n      // compute the status of the response,\n      //\n      // When in browser mode, using XDR or JSONP, we have no statusCode available\n      // So we rely on our API response `status` property.\n      // But `waitTask` can set a `status` property which is not the statusCode (it's the task status)\n      // So we check if there's a `message` along `status` and it means it's an error\n      //\n      // That's the only case where we have a response.status that's not the http statusCode\n      var status = httpResponse && httpResponse.body && httpResponse.body.message && httpResponse.body.status ||\n\n        // this is important to check the request statusCode AFTER the body eventual\n        // statusCode because some implementations (jQuery XDomainRequest transport) may\n        // send statusCode 200 while we had an error\n        httpResponse.statusCode ||\n\n        // When in browser mode, using XDR or JSONP\n        // we default to success when no error (no response.status && response.message)\n        // If there was a JSON.parse() error then body is null and it fails\n        httpResponse && httpResponse.body && 200;\n\n      requestDebug('received response: statusCode: %s, computed statusCode: %d, headers: %j',\n        httpResponse.statusCode, status, httpResponse.headers);\n\n      var httpResponseOk = Math.floor(status / 100) === 2;\n\n      var endTime = new Date();\n      debugData.push({\n        currentHost: currentHost,\n        headers: removeCredentials(headers),\n        content: body || null,\n        contentLength: body !== undefined ? body.length : null,\n        method: reqOpts.method,\n        timeouts: reqOpts.timeouts,\n        url: reqOpts.url,\n        startTime: startTime,\n        endTime: endTime,\n        duration: endTime - startTime,\n        statusCode: status\n      });\n\n      if (httpResponseOk) {\n        if (client._useCache && !client._useRequestCache && cache) {\n          cache[cacheID] = httpResponse.responseText;\n        }\n\n        return {\n          responseText: httpResponse.responseText,\n          body: httpResponse.body\n        };\n      }\n\n      var shouldRetry = Math.floor(status / 100) !== 4;\n\n      if (shouldRetry) {\n        tries += 1;\n        return retryRequest();\n      }\n\n      requestDebug('unrecoverable error');\n\n      // no success and no retry => fail\n      var unrecoverableError = new errors.AlgoliaSearchError(\n        httpResponse.body && httpResponse.body.message, {debugData: debugData, statusCode: status}\n      );\n\n      return client._promise.reject(unrecoverableError);\n    }\n\n    function tryFallback(err) {\n      // error cases:\n      //  While not in fallback mode:\n      //    - CORS not supported\n      //    - network error\n      //  While in fallback mode:\n      //    - timeout\n      //    - network error\n      //    - badly formatted JSONP (script loaded, did not call our callback)\n      //  In both cases:\n      //    - uncaught exception occurs (TypeError)\n      requestDebug('error: %s, stack: %s', err.message, err.stack);\n\n      var endTime = new Date();\n      debugData.push({\n        currentHost: currentHost,\n        headers: removeCredentials(headers),\n        content: body || null,\n        contentLength: body !== undefined ? body.length : null,\n        method: reqOpts.method,\n        timeouts: reqOpts.timeouts,\n        url: reqOpts.url,\n        startTime: startTime,\n        endTime: endTime,\n        duration: endTime - startTime\n      });\n\n      if (!(err instanceof errors.AlgoliaSearchError)) {\n        err = new errors.Unknown(err && err.message, err);\n      }\n\n      tries += 1;\n\n      // stop the request implementation when:\n      if (\n        // we did not generate this error,\n        // it comes from a throw in some other piece of code\n        err instanceof errors.Unknown ||\n\n        // server sent unparsable JSON\n        err instanceof errors.UnparsableJSON ||\n\n        // max tries and already using fallback or no fallback\n        tries >= client.hosts[initialOpts.hostType].length &&\n        (usingFallback || !hasFallback)) {\n        // stop request implementation for this command\n        err.debugData = debugData;\n        return client._promise.reject(err);\n      }\n\n      // When a timeout occured, retry by raising timeout\n      if (err instanceof errors.RequestTimeout) {\n        return retryRequestWithHigherTimeout();\n      }\n\n      return retryRequest();\n    }\n\n    function retryRequest() {\n      requestDebug('retrying request');\n      client._incrementHostIndex(initialOpts.hostType);\n      return doRequest(requester, reqOpts);\n    }\n\n    function retryRequestWithHigherTimeout() {\n      requestDebug('retrying request with higher timeout');\n      client._incrementHostIndex(initialOpts.hostType);\n      client._incrementTimeoutMultipler();\n      reqOpts.timeouts = client._getTimeoutsForRequest(initialOpts.hostType);\n      return doRequest(requester, reqOpts);\n    }\n  }\n\n  function isCacheValidWithCurrentID(\n    useRequestCache,\n    currentCache,\n    currentCacheID\n  ) {\n    return (\n      client._useCache &&\n      useRequestCache &&\n      currentCache &&\n      currentCache[currentCacheID] !== undefined\n    );\n  }\n\n\n  function interopCallbackReturn(request, callback) {\n    if (isCacheValidWithCurrentID(client._useRequestCache, cache, cacheID)) {\n      request.catch(function() {\n        // Release the cache on error\n        delete cache[cacheID];\n      });\n    }\n\n    if (typeof initialOpts.callback === 'function') {\n      // either we have a callback\n      request.then(function okCb(content) {\n        exitPromise(function() {\n          initialOpts.callback(null, callback(content));\n        }, client._setTimeout || setTimeout);\n      }, function nookCb(err) {\n        exitPromise(function() {\n          initialOpts.callback(err);\n        }, client._setTimeout || setTimeout);\n      });\n    } else {\n      // either we are using promises\n      return request.then(callback);\n    }\n  }\n\n  if (client._useCache && client._useRequestCache) {\n    cacheID = initialOpts.url;\n  }\n\n  // as we sometime use POST requests to pass parameters (like query='aa'),\n  // the cacheID must also include the body to be different between calls\n  if (client._useCache && client._useRequestCache && body) {\n    cacheID += '_body_' + body;\n  }\n\n  if (isCacheValidWithCurrentID(client._useRequestCache, cache, cacheID)) {\n    requestDebug('serving request from cache');\n\n    var maybePromiseForCache = cache[cacheID];\n\n    // In case the cache is warmup with value that is not a promise\n    var promiseForCache = typeof maybePromiseForCache.then !== 'function'\n      ? client._promise.resolve({responseText: maybePromiseForCache})\n      : maybePromiseForCache;\n\n    return interopCallbackReturn(promiseForCache, function(content) {\n      // In case of the cache request, return the original value\n      return JSON.parse(content.responseText);\n    });\n  }\n\n  var request = doRequest(\n    client._request, {\n      url: initialOpts.url,\n      method: initialOpts.method,\n      body: body,\n      jsonBody: initialOpts.body,\n      timeouts: client._getTimeoutsForRequest(initialOpts.hostType),\n      forceAuthHeaders: initialOpts.forceAuthHeaders\n    }\n  );\n\n  if (client._useCache && client._useRequestCache && cache) {\n    cache[cacheID] = request;\n  }\n\n  return interopCallbackReturn(request, function(content) {\n    // In case of the first request, return the JSON value\n    return content.body;\n  });\n};\n\n/*\n* Transform search param object in query string\n* @param {object} args arguments to add to the current query string\n* @param {string} params current query string\n* @return {string} the final query string\n*/\nAlgoliaSearchCore.prototype._getSearchParams = function(args, params) {\n  if (args === undefined || args === null) {\n    return params;\n  }\n  for (var key in args) {\n    if (key !== null && args[key] !== undefined && args.hasOwnProperty(key)) {\n      params += params === '' ? '' : '&';\n      params += key + '=' + encodeURIComponent(Object.prototype.toString.call(args[key]) === '[object Array]' ? safeJSONStringify(args[key]) : args[key]);\n    }\n  }\n  return params;\n};\n\n/**\n * Compute the headers for a request\n *\n * @param [string] options.additionalUA semi-colon separated string with other user agents to add\n * @param [boolean=true] options.withApiKey Send the api key as a header\n * @param [Object] options.headers Extra headers to send\n */\nAlgoliaSearchCore.prototype._computeRequestHeaders = function(options) {\n  var forEach = require('foreach');\n\n  var ua = options.additionalUA ?\n    this._ua + ';' + options.additionalUA :\n    this._ua;\n\n  var requestHeaders = {\n    'x-algolia-agent': ua,\n    'x-algolia-application-id': this.applicationID\n  };\n\n  // browser will inline headers in the url, node.js will use http headers\n  // but in some situations, the API KEY will be too long (big secured API keys)\n  // so if the request is a POST and the KEY is very long, we will be asked to not put\n  // it into headers but in the JSON body\n  if (options.withApiKey !== false) {\n    requestHeaders['x-algolia-api-key'] = this.apiKey;\n  }\n\n  if (this.userToken) {\n    requestHeaders['x-algolia-usertoken'] = this.userToken;\n  }\n\n  if (this.securityTags) {\n    requestHeaders['x-algolia-tagfilters'] = this.securityTags;\n  }\n\n  forEach(this.extraHeaders, function addToRequestHeaders(value, key) {\n    requestHeaders[key] = value;\n  });\n\n  if (options.headers) {\n    forEach(options.headers, function addToRequestHeaders(value, key) {\n      requestHeaders[key] = value;\n    });\n  }\n\n  return requestHeaders;\n};\n\n/**\n * Search through multiple indices at the same time\n * @param  {Object[]}   queries  An array of queries you want to run.\n * @param {string} queries[].indexName The index name you want to target\n * @param {string} [queries[].query] The query to issue on this index. Can also be passed into `params`\n * @param {Object} queries[].params Any search param like hitsPerPage, ..\n * @param  {Function} callback Callback to be called\n * @return {Promise|undefined} Returns a promise if no callback given\n */\nAlgoliaSearchCore.prototype.search = function(queries, opts, callback) {\n  var isArray = require('isarray');\n  var map = require('./map.js');\n\n  var usage = 'Usage: client.search(arrayOfQueries[, callback])';\n\n  if (!isArray(queries)) {\n    throw new Error(usage);\n  }\n\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  } else if (opts === undefined) {\n    opts = {};\n  }\n\n  var client = this;\n\n  var postObj = {\n    requests: map(queries, function prepareRequest(query) {\n      var params = '';\n\n      // allow query.query\n      // so we are mimicing the index.search(query, params) method\n      // {indexName:, query:, params:}\n      if (query.query !== undefined) {\n        params += 'query=' + encodeURIComponent(query.query);\n      }\n\n      return {\n        indexName: query.indexName,\n        params: client._getSearchParams(query.params, params)\n      };\n    })\n  };\n\n  var JSONPParams = map(postObj.requests, function prepareJSONPParams(request, requestId) {\n    return requestId + '=' +\n      encodeURIComponent(\n        '/1/indexes/' + encodeURIComponent(request.indexName) + '?' +\n        request.params\n      );\n  }).join('&');\n\n  var url = '/1/indexes/*/queries';\n\n  if (opts.strategy !== undefined) {\n    postObj.strategy = opts.strategy;\n  }\n\n  return this._jsonRequest({\n    cache: this.cache,\n    method: 'POST',\n    url: url,\n    body: postObj,\n    hostType: 'read',\n    fallback: {\n      method: 'GET',\n      url: '/1/indexes/*',\n      body: {\n        params: JSONPParams\n      }\n    },\n    callback: callback\n  });\n};\n\n/**\n* Search for facet values\n* https://www.algolia.com/doc/rest-api/search#search-for-facet-values\n* This is the top-level API for SFFV.\n*\n* @param {object[]} queries An array of queries to run.\n* @param {string} queries[].indexName Index name, name of the index to search.\n* @param {object} queries[].params Query parameters.\n* @param {string} queries[].params.facetName Facet name, name of the attribute to search for values in.\n* Must be declared as a facet\n* @param {string} queries[].params.facetQuery Query for the facet search\n* @param {string} [queries[].params.*] Any search parameter of Algolia,\n* see https://www.algolia.com/doc/api-client/javascript/search#search-parameters\n* Pagination is not supported. The page and hitsPerPage parameters will be ignored.\n*/\nAlgoliaSearchCore.prototype.searchForFacetValues = function(queries) {\n  var isArray = require('isarray');\n  var map = require('./map.js');\n\n  var usage = 'Usage: client.searchForFacetValues([{indexName, params: {facetName, facetQuery, ...params}}, ...queries])'; // eslint-disable-line max-len\n\n  if (!isArray(queries)) {\n    throw new Error(usage);\n  }\n\n  var client = this;\n\n  return client._promise.all(map(queries, function performQuery(query) {\n    if (\n      !query ||\n      query.indexName === undefined ||\n      query.params.facetName === undefined ||\n      query.params.facetQuery === undefined\n    ) {\n      throw new Error(usage);\n    }\n\n    var clone = require('./clone.js');\n    var omit = require('./omit.js');\n\n    var indexName = query.indexName;\n    var params = query.params;\n\n    var facetName = params.facetName;\n    var filteredParams = omit(clone(params), function(keyName) {\n      return keyName === 'facetName';\n    });\n    var searchParameters = client._getSearchParams(filteredParams, '');\n\n    return client._jsonRequest({\n      cache: client.cache,\n      method: 'POST',\n      url:\n        '/1/indexes/' +\n        encodeURIComponent(indexName) +\n        '/facets/' +\n        encodeURIComponent(facetName) +\n        '/query',\n      hostType: 'read',\n      body: {params: searchParameters}\n    });\n  }));\n};\n\n/**\n * Set the extra security tagFilters header\n * @param {string|array} tags The list of tags defining the current security filters\n */\nAlgoliaSearchCore.prototype.setSecurityTags = function(tags) {\n  if (Object.prototype.toString.call(tags) === '[object Array]') {\n    var strTags = [];\n    for (var i = 0; i < tags.length; ++i) {\n      if (Object.prototype.toString.call(tags[i]) === '[object Array]') {\n        var oredTags = [];\n        for (var j = 0; j < tags[i].length; ++j) {\n          oredTags.push(tags[i][j]);\n        }\n        strTags.push('(' + oredTags.join(',') + ')');\n      } else {\n        strTags.push(tags[i]);\n      }\n    }\n    tags = strTags.join(',');\n  }\n\n  this.securityTags = tags;\n};\n\n/**\n * Set the extra user token header\n * @param {string} userToken The token identifying a uniq user (used to apply rate limits)\n */\nAlgoliaSearchCore.prototype.setUserToken = function(userToken) {\n  this.userToken = userToken;\n};\n\n/**\n * Clear all queries in client's cache\n * @return undefined\n */\nAlgoliaSearchCore.prototype.clearCache = function() {\n  this.cache = {};\n};\n\n/**\n* Set the number of milliseconds a request can take before automatically being terminated.\n* @deprecated\n* @param {Number} milliseconds\n*/\nAlgoliaSearchCore.prototype.setRequestTimeout = function(milliseconds) {\n  if (milliseconds) {\n    this._timeouts.connect = this._timeouts.read = this._timeouts.write = milliseconds;\n  }\n};\n\n/**\n* Set the three different (connect, read, write) timeouts to be used when requesting\n* @param {Object} timeouts\n*/\nAlgoliaSearchCore.prototype.setTimeouts = function(timeouts) {\n  this._timeouts = timeouts;\n};\n\n/**\n* Get the three different (connect, read, write) timeouts to be used when requesting\n* @param {Object} timeouts\n*/\nAlgoliaSearchCore.prototype.getTimeouts = function() {\n  return this._timeouts;\n};\n\nAlgoliaSearchCore.prototype._getAppIdData = function() {\n  var data = store.get(this.applicationID);\n  if (data !== null) this._cacheAppIdData(data);\n  return data;\n};\n\nAlgoliaSearchCore.prototype._setAppIdData = function(data) {\n  data.lastChange = (new Date()).getTime();\n  this._cacheAppIdData(data);\n  return store.set(this.applicationID, data);\n};\n\nAlgoliaSearchCore.prototype._checkAppIdData = function() {\n  var data = this._getAppIdData();\n  var now = (new Date()).getTime();\n  if (data === null || now - data.lastChange > RESET_APP_DATA_TIMER) {\n    return this._resetInitialAppIdData(data);\n  }\n\n  return data;\n};\n\nAlgoliaSearchCore.prototype._resetInitialAppIdData = function(data) {\n  var newData = data || {};\n  newData.hostIndexes = {read: 0, write: 0};\n  newData.timeoutMultiplier = 1;\n  newData.shuffleResult = newData.shuffleResult || shuffle([1, 2, 3]);\n  return this._setAppIdData(newData);\n};\n\nAlgoliaSearchCore.prototype._cacheAppIdData = function(data) {\n  this._hostIndexes = data.hostIndexes;\n  this._timeoutMultiplier = data.timeoutMultiplier;\n  this._shuffleResult = data.shuffleResult;\n};\n\nAlgoliaSearchCore.prototype._partialAppIdDataUpdate = function(newData) {\n  var foreach = require('foreach');\n  var currentData = this._getAppIdData();\n  foreach(newData, function(value, key) {\n    currentData[key] = value;\n  });\n\n  return this._setAppIdData(currentData);\n};\n\nAlgoliaSearchCore.prototype._getHostByType = function(hostType) {\n  return this.hosts[hostType][this._getHostIndexByType(hostType)];\n};\n\nAlgoliaSearchCore.prototype._getTimeoutMultiplier = function() {\n  return this._timeoutMultiplier;\n};\n\nAlgoliaSearchCore.prototype._getHostIndexByType = function(hostType) {\n  return this._hostIndexes[hostType];\n};\n\nAlgoliaSearchCore.prototype._setHostIndexByType = function(hostIndex, hostType) {\n  var clone = require('./clone');\n  var newHostIndexes = clone(this._hostIndexes);\n  newHostIndexes[hostType] = hostIndex;\n  this._partialAppIdDataUpdate({hostIndexes: newHostIndexes});\n  return hostIndex;\n};\n\nAlgoliaSearchCore.prototype._incrementHostIndex = function(hostType) {\n  return this._setHostIndexByType(\n    (this._getHostIndexByType(hostType) + 1) % this.hosts[hostType].length, hostType\n  );\n};\n\nAlgoliaSearchCore.prototype._incrementTimeoutMultipler = function() {\n  var timeoutMultiplier = Math.max(this._timeoutMultiplier + 1, 4);\n  return this._partialAppIdDataUpdate({timeoutMultiplier: timeoutMultiplier});\n};\n\nAlgoliaSearchCore.prototype._getTimeoutsForRequest = function(hostType) {\n  return {\n    connect: this._timeouts.connect * this._timeoutMultiplier,\n    complete: this._timeouts[hostType] * this._timeoutMultiplier\n  };\n};\n\nfunction prepareHost(protocol) {\n  return function prepare(host) {\n    return protocol + '//' + host.toLowerCase();\n  };\n}\n\n// Prototype.js < 1.7, a widely used library, defines a weird\n// Array.prototype.toJSON function that will fail to stringify our content\n// appropriately\n// refs:\n//   - https://groups.google.com/forum/#!topic/prototype-core/E-SAVvV_V9Q\n//   - https://github.com/sstephenson/prototype/commit/038a2985a70593c1a86c230fadbdfe2e4898a48c\n//   - http://stackoverflow.com/a/3148441/147079\nfunction safeJSONStringify(obj) {\n  /* eslint no-extend-native:0 */\n\n  if (Array.prototype.toJSON === undefined) {\n    return JSON.stringify(obj);\n  }\n\n  var toJSON = Array.prototype.toJSON;\n  delete Array.prototype.toJSON;\n  var out = JSON.stringify(obj);\n  Array.prototype.toJSON = toJSON;\n\n  return out;\n}\n\nfunction shuffle(array) {\n  var currentIndex = array.length;\n  var temporaryValue;\n  var randomIndex;\n\n  // While there remain elements to shuffle...\n  while (currentIndex !== 0) {\n    // Pick a remaining element...\n    randomIndex = Math.floor(Math.random() * currentIndex);\n    currentIndex -= 1;\n\n    // And swap it with the current element.\n    temporaryValue = array[currentIndex];\n    array[currentIndex] = array[randomIndex];\n    array[randomIndex] = temporaryValue;\n  }\n\n  return array;\n}\n\nfunction removeCredentials(headers) {\n  var newHeaders = {};\n\n  for (var headerName in headers) {\n    if (Object.prototype.hasOwnProperty.call(headers, headerName)) {\n      var value;\n\n      if (headerName === 'x-algolia-api-key' || headerName === 'x-algolia-application-id') {\n        value = '**hidden for security purposes**';\n      } else {\n        value = headers[headerName];\n      }\n\n      newHeaders[headerName] = value;\n    }\n  }\n\n  return newHeaders;\n}\n","'use strict';\n\nvar forEach = require('lodash/forEach');\nvar map = require('lodash/map');\nvar reduce = require('lodash/reduce');\nvar merge = require('lodash/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 = [];\n\n    // One query for the hits\n    queries.push({\n      indexName: index,\n      params: requestBuilder._getHitsSearchParams(state)\n    });\n\n    // One for each disjunctive facets\n    forEach(state.getRefinedDisjunctiveFacets(), function(refinedFacet) {\n      queries.push({\n        indexName: index,\n        params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet)\n      });\n    });\n\n    // maybe more to get the root level of hierarchical facets when activated\n    forEach(state.getRefinedHierarchicalFacets(), function(refinedFacet) {\n      var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);\n\n      var currentRefinement = state.getHierarchicalRefinement(refinedFacet);\n      // if we are deeper than level 0 (starting from `beer > IPA`)\n      // we want to get the root values\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\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\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(state) {\n    var facets = state.facets\n      .concat(state.disjunctiveFacets)\n      .concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state));\n\n\n    var facetFilters = requestBuilder._getFacetFilters(state);\n    var numericFilters = requestBuilder._getNumericFilters(state);\n    var tagFilters = requestBuilder._getTagFilters(state);\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(state, facet, hierarchicalRootLevel) {\n    var facetFilters = requestBuilder._getFacetFilters(state, facet, hierarchicalRootLevel);\n    var numericFilters = requestBuilder._getNumericFilters(state, facet);\n    var tagFilters = requestBuilder._getTagFilters(state);\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\n    var hierarchicalFacet = state.getHierarchicalFacetByName(facet);\n\n    if (hierarchicalFacet) {\n      additionalParams.facets = requestBuilder._getDisjunctiveHierarchicalFacetAttribute(\n        state,\n        hierarchicalFacet,\n        hierarchicalRootLevel\n      );\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(state, facetName) {\n    if (state.numericFilters) {\n      return state.numericFilters;\n    }\n\n    var numericFilters = [];\n\n    forEach(state.numericRefinements, function(operators, attribute) {\n      forEach(operators, function(values, operator) {\n        if (facetName !== attribute) {\n          forEach(values, function(value) {\n            if (Array.isArray(value)) {\n              var vs = map(value, 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\n    return numericFilters;\n  },\n\n  /**\n   * Return the tags filters depending\n   * @private\n   * @return {string}\n   */\n  _getTagFilters: function(state) {\n    if (state.tagFilters) {\n      return state.tagFilters;\n    }\n\n    return state.tagRefinements.join(',');\n  },\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(state, facet, hierarchicalRootLevel) {\n    var facetFilters = [];\n\n    forEach(state.facetsRefinements, function(facetValues, facetName) {\n      forEach(facetValues, function(facetValue) {\n        facetFilters.push(facetName + ':' + facetValue);\n      });\n    });\n\n    forEach(state.facetsExcludes, function(facetValues, facetName) {\n      forEach(facetValues, function(facetValue) {\n        facetFilters.push(facetName + ':-' + facetValue);\n      });\n    });\n\n    forEach(state.disjunctiveFacetsRefinements, function(facetValues, facetName) {\n      if (facetName === facet || !facetValues || facetValues.length === 0) return;\n      var orFilters = [];\n\n      forEach(facetValues, function(facetValue) {\n        orFilters.push(facetName + ':' + facetValue);\n      });\n\n      facetFilters.push(orFilters);\n    });\n\n    forEach(state.hierarchicalFacetsRefinements, function(facetValues, facetName) {\n      var facetValue = facetValues[0];\n\n      if (facetValue === undefined) {\n        return;\n      }\n\n      var hierarchicalFacet = state.getHierarchicalFacetByName(facetName);\n      var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n      var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n      var attributeToRefine;\n      var attributesIndex;\n\n      // we ask for parent facet values only when the `facet` is the current hierarchical facet\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) ||\n          (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\n        attributeToRefine = hierarchicalFacet.attributes[attributesIndex];\n      }\n\n      if (attributeToRefine) {\n        facetFilters.push([attributeToRefine + ':' + facetValue]);\n      }\n    });\n\n    return facetFilters;\n  },\n\n  _getHitsHierarchicalFacetsAttributes: function(state) {\n    var out = [];\n\n    return reduce(\n      state.hierarchicalFacets,\n      // ask for as much levels as there's hierarchical refinements\n      function getHitsAttributesForHierarchicalFacet(allAttributes, hierarchicalFacet) {\n        var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0];\n\n        // if no refinement, ask for root level\n        if (!hierarchicalRefinement) {\n          allAttributes.push(hierarchicalFacet.attributes[0]);\n          return allAttributes;\n        }\n\n        var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n        var level = hierarchicalRefinement.split(separator).length;\n        var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);\n\n        return allAttributes.concat(newAttributes);\n      }, out);\n  },\n\n  _getDisjunctiveHierarchicalFacetAttribute: function(state, hierarchicalFacet, rootLevel) {\n    var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);\n    if (rootLevel === true) {\n      var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);\n      var attributeIndex = 0;\n\n      if (rootPath) {\n        attributeIndex = rootPath.split(separator).length;\n      }\n      return [hierarchicalFacet.attributes[attributeIndex]];\n    }\n\n    var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || '';\n    // 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\n  getSearchForFacetQuery: function(facetName, query, maxFacetHits, state) {\n    var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ?\n      state.clearRefinements(facetName) :\n      state;\n    var searchForFacetSearchParameters = {\n      facetQuery: query,\n      facetName: facetName\n    };\n    if (typeof maxFacetHits === 'number') {\n      searchForFacetSearchParameters.maxFacetHits = maxFacetHits;\n    }\n    var queries = merge(requestBuilder._getHitsSearchParams(stateForSearchForFacetValues), searchForFacetSearchParameters);\n    return queries;\n  }\n};\n\nmodule.exports = requestBuilder;\n","module.exports = createPlacesClient;\n\nvar qs3 = require('querystring-es3');\nvar buildSearchMethod = require('./buildSearchMethod.js');\n\nfunction createPlacesClient(algoliasearch) {\n  return function places(appID, apiKey, opts) {\n    var cloneDeep = require('./clone.js');\n\n    opts = opts && cloneDeep(opts) || {};\n    opts.hosts = opts.hosts || [\n      'places-dsn.algolia.net',\n      'places-1.algolianet.com',\n      'places-2.algolianet.com',\n      'places-3.algolianet.com'\n    ];\n\n    // allow initPlaces() no arguments => community rate limited\n    if (arguments.length === 0 || typeof appID === 'object' || appID === undefined) {\n      appID = '';\n      apiKey = '';\n      opts._allowEmptyCredentials = true;\n    }\n\n    var client = algoliasearch(appID, apiKey, opts);\n    var index = client.initIndex('places');\n    index.search = buildSearchMethod('query', '/1/places/query');\n    index.reverse = function(options, callback) {\n      var encoded = qs3.encode(options);\n\n      return this.as._jsonRequest({\n        method: 'GET',\n        url: '/1/places/reverse?' + encoded,\n        hostType: 'read',\n        callback: callback\n      });\n    };\n\n    index.getObject = function(objectID, callback) {\n      return this.as._jsonRequest({\n        method: 'GET',\n        url: '/1/places/' + encodeURIComponent(objectID),\n        hostType: 'read',\n        callback: callback\n      });\n    };\n    return index;\n  };\n}\n","'use strict';\n\nmodule.exports = '2.26.1';\n","'use strict';\n\nvar SearchParameters = require('./SearchParameters');\nvar SearchResults = require('./SearchResults');\nvar DerivedHelper = require('./DerivedHelper');\nvar requestBuilder = require('./requestBuilder');\n\nvar util = require('util');\nvar events = require('events');\n\nvar flatten = require('lodash/flatten');\nvar forEach = require('lodash/forEach');\nvar isEmpty = require('lodash/isEmpty');\nvar map = require('lodash/map');\n\nvar url = require('./url');\nvar version = require('./version');\n\n/**\n * Event triggered when a parameter is set or updated\n * @event AlgoliaSearchHelper#event:change\n * @property {SearchParameters} state the current parameters with the latest changes applied\n * @property {SearchResults} lastResults the previous results received from Algolia. `null` before\n * the first request\n * @example\n * helper.on('change', function(state, lastResults) {\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 {SearchParameters} state the parameters used for this search\n * @property {SearchResults} lastResults the results from the previous search. `null` if\n * it is the first search.\n * @example\n * helper.on('search', function(state, lastResults) {\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 {SearchParameters} state the parameters used for this search\n * it is the first search.\n * @property {string} facet the facet searched into\n * @property {string} query the query used to search in the facets\n * @example\n * helper.on('searchForFacetValues', function(state, facet, query) {\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 {SearchParameters} state the parameters used for this search\n * it is the first search.\n * @example\n * helper.on('searchOnce', function(state) {\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 {SearchResults} results the results received from Algolia\n * @property {SearchParameters} state the parameters used to query Algolia. Those might\n * be different from the one in the helper instance (for example if the network is unreliable).\n * @example\n * helper.on('result', function(results, state) {\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 {Error} error the error returned by the Algolia.\n * @example\n * helper.on('error', function(error) {\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 */\nfunction AlgoliaSearchHelper(client, index, options) {\n  if (client.addAlgoliaAgent && !doesClientAgentContainsHelper(client)) {\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\nutil.inherits(AlgoliaSearchHelper, events.EventEmitter);\n\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 */\nAlgoliaSearchHelper.prototype.search = function() {\n  this._search();\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.getQuery = function() {\n  var state = this.state;\n  return requestBuilder._getHitsSearchParams(state);\n};\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 */\nAlgoliaSearchHelper.prototype.searchOnce = function(options, cb) {\n  var tempState = !options ? this.state : this.state.setQueryParameters(options);\n  var queries = requestBuilder._getQueries(tempState.index, tempState);\n  var self = this;\n\n  this._currentNbQueries++;\n\n  this.emit('searchOnce', tempState);\n\n  if (cb) {\n    this.client\n      .search(queries)\n      .then(function(content) {\n        self._currentNbQueries--;\n        if (self._currentNbQueries === 0) {\n          self.emit('searchQueueEmpty');\n        }\n\n        cb(null, new SearchResults(tempState, content.results), tempState);\n      })\n      .catch(function(err) {\n        self._currentNbQueries--;\n        if (self._currentNbQueries === 0) {\n          self.emit('searchQueueEmpty');\n        }\n\n        cb(err, null, tempState);\n      });\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/**\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 */\nAlgoliaSearchHelper.prototype.searchForFacetValues = function(facet, query, maxFacetHits, userState) {\n  var state = this.state.setQueryParameters(userState || {});\n  var isDisjunctive = state.isDisjunctiveFacet(facet);\n  var algoliaQuery = requestBuilder.getSearchForFacetQuery(facet, query, maxFacetHits, state);\n\n  this._currentNbQueries++;\n  var self = this;\n\n  this.emit('searchForFacetValues', state, facet, query);\n  var searchForFacetValuesPromise = typeof this.client.searchForFacetValues === 'function'\n    ? this.client.searchForFacetValues([{indexName: state.index, params: algoliaQuery}])\n    : this.client.initIndex(state.index).searchForFacetValues(algoliaQuery);\n\n  return searchForFacetValuesPromise.then(function addIsRefined(content) {\n    self._currentNbQueries--;\n    if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');\n\n    content = Array.isArray(content) ? content[0] : content;\n\n    content.facetHits = forEach(content.facetHits, function(f) {\n      f.isRefined = isDisjunctive ?\n        state.isDisjunctiveFacetRefined(facet, f.value) :\n        state.isFacetRefined(facet, f.value);\n    });\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/**\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 */\nAlgoliaSearchHelper.prototype.setQuery = function(q) {\n  this._change(this.state.setPage(0).setQuery(q));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.clearRefinements = function(name) {\n  this._change(this.state.setPage(0).clearRefinements(name));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.clearTags = function() {\n  this._change(this.state.setPage(0).clearTags());\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function(facet, value) {\n  this._change(this.state.setPage(0).addDisjunctiveFacetRefinement(facet, value));\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addDisjunctiveFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.addDisjunctiveRefine = function() {\n  return this.addDisjunctiveFacetRefinement.apply(this, arguments);\n};\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 */\nAlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function(facet, value) {\n  this._change(this.state.setPage(0).addHierarchicalFacetRefinement(facet, value));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.addNumericRefinement = function(attribute, operator, value) {\n  this._change(this.state.setPage(0).addNumericRefinement(attribute, operator, value));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.addFacetRefinement = function(facet, value) {\n  this._change(this.state.setPage(0).addFacetRefinement(facet, value));\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.addRefine = function() {\n  return this.addFacetRefinement.apply(this, arguments);\n};\n\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 */\nAlgoliaSearchHelper.prototype.addFacetExclusion = function(facet, value) {\n  this._change(this.state.setPage(0).addExcludeRefinement(facet, value));\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetExclusion}\n */\nAlgoliaSearchHelper.prototype.addExclude = function() {\n  return this.addFacetExclusion.apply(this, arguments);\n};\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 */\nAlgoliaSearchHelper.prototype.addTag = function(tag) {\n  this._change(this.state.setPage(0).addTagRefinement(tag));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.removeNumericRefinement = function(attribute, operator, value) {\n  this._change(this.state.setPage(0).removeNumericRefinement(attribute, operator, value));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function(facet, value) {\n  this._change(this.state.setPage(0).removeDisjunctiveFacetRefinement(facet, value));\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeDisjunctiveFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function() {\n  return this.removeDisjunctiveFacetRefinement.apply(this, arguments);\n};\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 */\nAlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function(facet) {\n  this._change(this.state.setPage(0).removeHierarchicalFacetRefinement(facet));\n\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.removeFacetRefinement = function(facet, value) {\n  this._change(this.state.setPage(0).removeFacetRefinement(facet, value));\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.removeRefine = function() {\n  return this.removeFacetRefinement.apply(this, arguments);\n};\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 */\nAlgoliaSearchHelper.prototype.removeFacetExclusion = function(facet, value) {\n  this._change(this.state.setPage(0).removeExcludeRefinement(facet, value));\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetExclusion}\n */\nAlgoliaSearchHelper.prototype.removeExclude = function() {\n  return this.removeFacetExclusion.apply(this, arguments);\n};\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 */\nAlgoliaSearchHelper.prototype.removeTag = function(tag) {\n  this._change(this.state.setPage(0).removeTagRefinement(tag));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.toggleFacetExclusion = function(facet, value) {\n  this._change(this.state.setPage(0).toggleExcludeFacetRefinement(facet, value));\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetExclusion}\n */\nAlgoliaSearchHelper.prototype.toggleExclude = function() {\n  return this.toggleFacetExclusion.apply(this, arguments);\n};\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 */\nAlgoliaSearchHelper.prototype.toggleRefinement = function(facet, value) {\n  return this.toggleFacetRefinement(facet, value);\n};\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 */\nAlgoliaSearchHelper.prototype.toggleFacetRefinement = function(facet, value) {\n  this._change(this.state.setPage(0).toggleFacetRefinement(facet, value));\n  return this;\n};\n\n/**\n * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}\n */\nAlgoliaSearchHelper.prototype.toggleRefine = function() {\n  return this.toggleFacetRefinement.apply(this, arguments);\n};\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 */\nAlgoliaSearchHelper.prototype.toggleTag = function(tag) {\n  this._change(this.state.setPage(0).toggleTagRefinement(tag));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.nextPage = function() {\n  return this.setPage(this.state.page + 1);\n};\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 */\nAlgoliaSearchHelper.prototype.previousPage = function() {\n  return this.setPage(this.state.page - 1);\n};\n\n/**\n * @private\n */\nfunction setCurrentPage(page) {\n  if (page < 0) throw new Error('Page requested below 0.');\n\n  this._change(this.state.setPage(page));\n  return this;\n}\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 */\nAlgoliaSearchHelper.prototype.setCurrentPage = setCurrentPage;\n\n/**\n * Updates the current page.\n * @function\n * @param  {number} page The page number\n * @return {AlgoliaSearchHelper}\n * @fires change\n * @chainable\n */\nAlgoliaSearchHelper.prototype.setPage = setCurrentPage;\n\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 */\nAlgoliaSearchHelper.prototype.setIndex = function(name) {\n  this._change(this.state.setPage(0).setIndex(name));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.setQueryParameter = function(parameter, value) {\n  this._change(this.state.setPage(0).setQueryParameter(parameter, value));\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.setState = function(newState) {\n  this._change(SearchParameters.make(newState));\n  return this;\n};\n\n/**\n * Get the current search state stored in the helper. This object is immutable.\n * @param {string[]} [filters] optional filters to retrieve only a subset of the state\n * @return {SearchParameters|object} if filters is specified a plain object is\n * returned containing only the requested fields, otherwise return the unfiltered\n * state\n * @example\n * // Get the complete state as stored in the helper\n * helper.getState();\n * @example\n * // Get a part of the state with all the refinements on attributes and the query\n * helper.getState(['query', 'attribute:category']);\n */\nAlgoliaSearchHelper.prototype.getState = function(filters) {\n  if (filters === undefined) return this.state;\n  return this.state.filter(filters);\n};\n\n/**\n * DEPRECATED Get part of the state as a query string. By default, the output keys will not\n * be prefixed and will only take the applied refinements and the query.\n * @deprecated\n * @param {object} [options] May contain the following parameters :\n *\n * **filters** : possible values are all the keys of the [SearchParameters](#searchparameters), `index` for\n * the index, all the refinements with `attribute:*` or for some specific attributes with\n * `attribute:theAttribute`\n *\n * **prefix** : prefix in front of the keys\n *\n * **moreAttributes** : more values to be added in the query string. Those values\n *    won't be prefixed.\n * @return {string} the query string\n */\nAlgoliaSearchHelper.prototype.getStateAsQueryString = function getStateAsQueryString(options) {\n  var filters = options && options.filters || ['query', 'attribute:*'];\n  var partialState = this.getState(filters);\n\n  return url.getQueryStringFromState(partialState, options);\n};\n\n/**\n * DEPRECATED Read a query string and return an object containing the state. Use\n * url module.\n * @deprecated\n * @static\n * @param {string} queryString the query string that will be decoded\n * @param {object} options accepted options :\n *   - prefix : the prefix used for the saved attributes, you have to provide the\n *     same that was used for serialization\n * @return {object} partial search parameters object (same properties than in the\n * SearchParameters but not exhaustive)\n * @see {@link url#getStateFromQueryString}\n */\nAlgoliaSearchHelper.getConfigurationFromQueryString = url.getStateFromQueryString;\n\n/**\n * DEPRECATED Retrieve an object of all the properties that are not understandable as helper\n * parameters. Use url module.\n * @deprecated\n * @static\n * @param {string} queryString the query string to read\n * @param {object} options the options\n *   - prefixForParameters : prefix used for the helper configuration keys\n * @return {object} the object containing the parsed configuration that doesn't\n * to the helper\n */\nAlgoliaSearchHelper.getForeignConfigurationInQueryString = url.getUnrecognizedParametersInQueryString;\n\n/**\n * DEPRECATED Overrides part of the state with the properties stored in the provided query\n * string.\n * @deprecated\n * @param {string} queryString the query string containing the informations to url the state\n * @param {object} options optional parameters :\n *  - prefix : prefix used for the algolia parameters\n *  - triggerChange : if set to true the state update will trigger a change event\n */\nAlgoliaSearchHelper.prototype.setStateFromQueryString = function(queryString, options) {\n  var triggerChange = options && options.triggerChange || false;\n  var configuration = url.getStateFromQueryString(queryString, options);\n  var updatedState = this.state.setQueryParameters(configuration);\n\n  if (triggerChange) this.setState(updatedState);\n  else this.overrideStateWithoutTriggeringChangeEvent(updatedState);\n};\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 */\nAlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function(newState) {\n  this.state = new SearchParameters(newState);\n  return this;\n};\n\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasRefinements}\n */\nAlgoliaSearchHelper.prototype.isRefined = function(facet, value) {\n  if (this.state.isConjunctiveFacet(facet)) {\n    return this.state.isFacetRefined(facet, value);\n  } else if (this.state.isDisjunctiveFacet(facet)) {\n    return this.state.isDisjunctiveFacetRefined(facet, value);\n  }\n\n  throw new Error(facet +\n    ' is not properly defined in this helper configuration' +\n    '(use the facets or disjunctiveFacets keys to configure it)');\n};\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 */\nAlgoliaSearchHelper.prototype.hasRefinements = function(attribute) {\n  if (!isEmpty(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  }\n\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  return false;\n};\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 */\nAlgoliaSearchHelper.prototype.isExcluded = function(facet, value) {\n  return this.state.isExcludeRefined(facet, value);\n};\n\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasRefinements}\n */\nAlgoliaSearchHelper.prototype.isDisjunctiveRefined = function(facet, value) {\n  return this.state.isDisjunctiveFacetRefined(facet, value);\n};\n\n/**\n * Check if the string is a currently filtering tag.\n * @param {string} tag tag to check\n * @return {boolean}\n */\nAlgoliaSearchHelper.prototype.hasTag = function(tag) {\n  return this.state.isTagRefined(tag);\n};\n\n/**\n * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasTag}\n */\nAlgoliaSearchHelper.prototype.isTagRefined = function() {\n  return this.hasTagRefinements.apply(this, arguments);\n};\n\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 */\nAlgoliaSearchHelper.prototype.getIndex = function() {\n  return this.state.index;\n};\n\nfunction getCurrentPage() {\n  return this.state.page;\n}\n\n/**\n * Get the currently selected page\n * @deprecated\n * @return {number} the current page\n */\nAlgoliaSearchHelper.prototype.getCurrentPage = getCurrentPage;\n/**\n * Get the currently selected page\n * @function\n * @return {number} the current page\n */\nAlgoliaSearchHelper.prototype.getPage = getCurrentPage;\n\n/**\n * Get all the tags currently set to filters the results.\n *\n * @return {string[]} The list of tags currently set.\n */\nAlgoliaSearchHelper.prototype.getTags = function() {\n  return this.state.tagRefinements;\n};\n\n/**\n * Get a parameter of the search by its name. It is possible that a parameter is directly\n * defined in the index dashboard, but it will be undefined using this method.\n *\n * The complete list of parameters is\n * 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 have their own API)\n * @param {string} parameterName the parameter name\n * @return {any} the parameter value\n * @example\n * var hitsPerPage = helper.getQueryParameter('hitsPerPage');\n */\nAlgoliaSearchHelper.prototype.getQueryParameter = function(parameterName) {\n  return this.state.getQueryParameter(parameterName);\n};\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 */\nAlgoliaSearchHelper.prototype.getRefinements = function(facetName) {\n  var refinements = [];\n\n  if (this.state.isConjunctiveFacet(facetName)) {\n    var conjRefinements = this.state.getConjunctiveRefinements(facetName);\n\n    forEach(conjRefinements, function(r) {\n      refinements.push({\n        value: r,\n        type: 'conjunctive'\n      });\n    });\n\n    var excludeRefinements = this.state.getExcludeRefinements(facetName);\n\n    forEach(excludeRefinements, 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\n    forEach(disjRefinements, function(r) {\n      refinements.push({\n        value: r,\n        type: 'disjunctive'\n      });\n    });\n  }\n\n  var numericRefinements = this.state.getNumericRefinements(facetName);\n\n  forEach(numericRefinements, function(value, operator) {\n    refinements.push({\n      value: value,\n      operator: operator,\n      type: 'numeric'\n    });\n  });\n\n  return refinements;\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 */\nAlgoliaSearchHelper.prototype.getNumericRefinement = function(attribute, operator) {\n  return this.state.getNumericRefinement(attribute, operator);\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 */\nAlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function(facetName) {\n  return this.state.getHierarchicalFacetBreadcrumb(facetName);\n};\n\n// /////////// PRIVATE\n\n/**\n * Perform the underlying queries\n * @private\n * @return {undefined}\n * @fires search\n * @fires result\n * @fires error\n */\nAlgoliaSearchHelper.prototype._search = function() {\n  var state = this.state;\n  var mainQueries = requestBuilder._getQueries(state.index, state);\n\n  var states = [{\n    state: state,\n    queriesCount: mainQueries.length,\n    helper: this\n  }];\n\n  this.emit('search', state, this.lastResults);\n\n  var derivedQueries = map(this.derivedHelpers, function(derivedHelper) {\n    var derivedState = derivedHelper.getModifiedState(state);\n    var queries = requestBuilder._getQueries(derivedState.index, derivedState);\n    states.push({\n      state: derivedState,\n      queriesCount: queries.length,\n      helper: derivedHelper\n    });\n    derivedHelper.emit('search', derivedState, derivedHelper.lastResults);\n    return queries;\n  });\n\n  var queries = mainQueries.concat(flatten(derivedQueries));\n  var queryId = this._queryId++;\n\n  this._currentNbQueries++;\n\n  try {\n    this.client.search(queries)\n      .then(this._dispatchAlgoliaResponse.bind(this, states, queryId))\n      .catch(this._dispatchAlgoliaError.bind(this, queryId));\n  } catch (err) {\n    // If we reach this part, we're in an internal error state\n    this.emit('error', err);\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 */\nAlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function(states, queryId, content) {\n  // FIXME remove the number of outdated queries discarded instead of just one\n\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= (queryId - this._lastQueryIdReceived);\n  this._lastQueryIdReceived = queryId;\n\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n\n  var results = content.results.slice();\n  forEach(states, 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\n    var formattedResponse = helper.lastResults = new SearchResults(state, specificResults);\n    helper.emit('result', formattedResponse, state);\n  });\n};\n\nAlgoliaSearchHelper.prototype._dispatchAlgoliaError = function(queryId, err) {\n  if (queryId < this._lastQueryIdReceived) {\n    // Outdated answer\n    return;\n  }\n\n  this._currentNbQueries -= queryId - this._lastQueryIdReceived;\n  this._lastQueryIdReceived = queryId;\n\n  this.emit('error', err);\n\n  if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');\n};\n\nAlgoliaSearchHelper.prototype.containsRefinement = function(query, facetFilters, numericFilters, tagFilters) {\n  return query ||\n    facetFilters.length !== 0 ||\n    numericFilters.length !== 0 ||\n    tagFilters.length !== 0;\n};\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 */\nAlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function(facet) {\n  return this.state.disjunctiveRefinements[facet] &&\n    this.state.disjunctiveRefinements[facet].length > 0;\n};\n\nAlgoliaSearchHelper.prototype._change = function(newState) {\n  if (newState !== this.state) {\n    this.state = newState;\n    this.emit('change', this.state, this.lastResults);\n  }\n};\n\n/**\n * Clears the cache of the underlying Algolia client.\n * @return {AlgoliaSearchHelper}\n */\nAlgoliaSearchHelper.prototype.clearCache = function() {\n  this.client.clearCache && this.client.clearCache();\n  return this;\n};\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 */\nAlgoliaSearchHelper.prototype.setClient = function(newClient) {\n  if (this.client === newClient) return this;\n\n  if (newClient.addAlgoliaAgent && !doesClientAgentContainsHelper(newClient)) newClient.addAlgoliaAgent('JS Helper ' + version);\n  this.client = newClient;\n\n  return this;\n};\n\n/**\n * Gets the instance of the currently used client.\n * @return {AlgoliaSearch}\n */\nAlgoliaSearchHelper.prototype.getClient = function() {\n  return this.client;\n};\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 */\nAlgoliaSearchHelper.prototype.derive = function(fn) {\n  var derivedHelper = new DerivedHelper(this, fn);\n  this.derivedHelpers.push(derivedHelper);\n  return derivedHelper;\n};\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 */\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/**\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 */\nAlgoliaSearchHelper.prototype.hasPendingRequests = function() {\n  return this._currentNbQueries > 0;\n};\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\n/*\n * This function tests if the _ua parameter of the client\n * already contains the JS Helper UA\n */\nfunction doesClientAgentContainsHelper(client) {\n  // this relies on JS Client internal variable, this might break if implementation changes\n  var currentAgent = client._ua;\n  return !currentAgent ? false :\n    currentAgent.indexOf('JS Helper') !== -1;\n}\n\nmodule.exports = AlgoliaSearchHelper;\n","var foreach = require('foreach');\n\nmodule.exports = function map(arr, fn) {\n  var newArr = [];\n  foreach(arr, function(item, itemIndex) {\n    newArr.push(fn(item, itemIndex, arr));\n  });\n  return newArr;\n};\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  'lightseagreen',\n  'forestgreen',\n  'goldenrod',\n  'dodgerblue',\n  'darkorchid',\n  'crimson'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // NB: In an Electron preload script, document will be defined but not fully\n  // initialized. Since we know we're in Chrome, we'll just detect this case\n  // explicitly\n  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {\n    return true;\n  }\n\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n  return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n    // double check webkit in userAgent just in case we are in a worker\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  try {\n    return JSON.stringify(v);\n  } catch (err) {\n    return '[UnexpectedJSONParseError]: ' + err.message;\n  }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return;\n\n  var c = 'color: ' + this.color;\n  args.splice(1, 0, c, 'color: inherit')\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-zA-Z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  var r;\n  try {\n    r = exports.storage.debug;\n  } catch(e) {}\n\n  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n  if (!r && typeof process !== 'undefined' && 'env' in process) {\n    r = process.env.DEBUG;\n  }\n\n  return r;\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n","module.exports = buildSearchMethod;\n\nvar errors = require('./errors.js');\n\n/**\n * Creates a search method to be used in clients\n * @param {string} queryParam the name of the attribute used for the query\n * @param {string} url the url\n * @return {function} the search method\n */\nfunction buildSearchMethod(queryParam, url) {\n  /**\n   * The search method. Prepares the data and send the query to Algolia.\n   * @param {string} query the string used for query search\n   * @param {object} args additional parameters to send with the search\n   * @param {function} [callback] the callback to be called with the client gets the answer\n   * @return {undefined|Promise} If the callback is not provided then this methods returns a Promise\n   */\n  return function search(query, args, callback) {\n    // warn V2 users on how to search\n    if (typeof query === 'function' && typeof args === 'object' ||\n      typeof callback === 'object') {\n      // .search(query, params, cb)\n      // .search(cb, params)\n      throw new errors.AlgoliaSearchError('index.search usage is index.search(query, params, cb)');\n    }\n\n    // Normalizing the function signature\n    if (arguments.length === 0 || typeof query === 'function') {\n      // Usage : .search(), .search(cb)\n      callback = query;\n      query = '';\n    } else if (arguments.length === 1 || typeof args === 'function') {\n      // Usage : .search(query/args), .search(query, cb)\n      callback = args;\n      args = undefined;\n    }\n    // At this point we have 3 arguments with values\n\n    // Usage : .search(args) // careful: typeof null === 'object'\n    if (typeof query === 'object' && query !== null) {\n      args = query;\n      query = undefined;\n    } else if (query === undefined || query === null) { // .search(undefined/null)\n      query = '';\n    }\n\n    var params = '';\n\n    if (query !== undefined) {\n      params += queryParam + '=' + encodeURIComponent(query);\n    }\n\n    var additionalUA;\n    if (args !== undefined) {\n      if (args.additionalUA) {\n        additionalUA = args.additionalUA;\n        delete args.additionalUA;\n      }\n      // `_getSearchParams` will augment params, do not be fooled by the = versus += from previous if\n      params = this.as._getSearchParams(args, params);\n    }\n\n\n    return this._search(params, url, callback, additionalUA);\n  };\n}\n","'use strict';\n\nmodule.exports = jsonpRequest;\n\nvar errors = require('../errors');\n\nvar JSONPCounter = 0;\n\nfunction jsonpRequest(url, opts, cb) {\n  if (opts.method !== 'GET') {\n    cb(new Error('Method ' + opts.method + ' ' + url + ' is not supported by JSONP.'));\n    return;\n  }\n\n  opts.debug('JSONP: start');\n\n  var cbCalled = false;\n  var timedOut = false;\n\n  JSONPCounter += 1;\n  var head = document.getElementsByTagName('head')[0];\n  var script = document.createElement('script');\n  var cbName = 'algoliaJSONP_' + JSONPCounter;\n  var done = false;\n\n  window[cbName] = function(data) {\n    removeGlobals();\n\n    if (timedOut) {\n      opts.debug('JSONP: Late answer, ignoring');\n      return;\n    }\n\n    cbCalled = true;\n\n    clean();\n\n    cb(null, {\n      body: data,\n      responseText: JSON.stringify(data)/* ,\n      // We do not send the statusCode, there's no statusCode in JSONP, it will be\n      // computed using data.status && data.message like with XDR\n      statusCode*/\n    });\n  };\n\n  // add callback by hand\n  url += '&callback=' + cbName;\n\n  // add body params manually\n  if (opts.jsonBody && opts.jsonBody.params) {\n    url += '&' + opts.jsonBody.params;\n  }\n\n  var ontimeout = setTimeout(timeout, opts.timeouts.complete);\n\n  // script onreadystatechange needed only for\n  // <= IE8\n  // https://github.com/angular/angular.js/issues/4523\n  script.onreadystatechange = readystatechange;\n  script.onload = success;\n  script.onerror = error;\n\n  script.async = true;\n  script.defer = true;\n  script.src = url;\n  head.appendChild(script);\n\n  function success() {\n    opts.debug('JSONP: success');\n\n    if (done || timedOut) {\n      return;\n    }\n\n    done = true;\n\n    // script loaded but did not call the fn => script loading error\n    if (!cbCalled) {\n      opts.debug('JSONP: Fail. Script loaded but did not call the callback');\n      clean();\n      cb(new errors.JSONPScriptFail());\n    }\n  }\n\n  function readystatechange() {\n    if (this.readyState === 'loaded' || this.readyState === 'complete') {\n      success();\n    }\n  }\n\n  function clean() {\n    clearTimeout(ontimeout);\n    script.onload = null;\n    script.onreadystatechange = null;\n    script.onerror = null;\n    head.removeChild(script);\n  }\n\n  function removeGlobals() {\n    try {\n      delete window[cbName];\n      delete window[cbName + '_loaded'];\n    } catch (e) {\n      window[cbName] = window[cbName + '_loaded'] = undefined;\n    }\n  }\n\n  function timeout() {\n    opts.debug('JSONP: Script timeout');\n    timedOut = true;\n    clean();\n    cb(new errors.RequestTimeout());\n  }\n\n  function error() {\n    opts.debug('JSONP: Script error');\n\n    if (done || timedOut) {\n      return;\n    }\n\n    clean();\n    cb(new errors.JSONPScriptError());\n  }\n}\n"],"sourceRoot":""}