instantsearch.js 4.56.6 → 4.56.7

package/dist/instantsearch.development.js

@@ -1,4 +1,4 @@
-/*! InstantSearch.js 4.56.6 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch.js */
+/*! InstantSearch.js 4.56.7 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch.js */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
@@ -5571,14 +5571,20 @@
   };
 
   function clone(value) {
-    if (_typeof(value) === 'object' && value !== null) {
+    if (typeof value === 'object' && value !== null) {
       return _merge(Array.isArray(value) ? [] : {}, value);
     }
     return value;
   }
+
   function isObjectOrArrayOrFunction(value) {
-    return typeof value === 'function' || Array.isArray(value) || Object.prototype.toString.call(value) === '[object Object]';
+    return (
+      typeof value === 'function' ||
+      Array.isArray(value) ||
+      Object.prototype.toString.call(value) === '[object Object]'
+    );
   }
+
   function _merge(target, source) {
     if (target === source) {
       return target;
@@ -5586,17 +5592,27 @@
 
     // eslint-disable-next-line no-restricted-syntax
     for (var key in source) {
-      if (!Object.prototype.hasOwnProperty.call(source, key) || key === '__proto__' || key === 'constructor') {
+      if (
+        !Object.prototype.hasOwnProperty.call(source, key) ||
+        key === '__proto__' ||
+        key === 'constructor'
+      ) {
         // eslint-disable-next-line no-continue
         continue;
       }
+
       var sourceVal = source[key];
       var targetVal = target[key];
+
       if (typeof targetVal !== 'undefined' && typeof sourceVal === 'undefined') {
         // eslint-disable-next-line no-continue
         continue;
       }
-      if (isObjectOrArrayOrFunction(targetVal) && isObjectOrArrayOrFunction(sourceVal)) {
+
+      if (
+        isObjectOrArrayOrFunction(targetVal) &&
+        isObjectOrArrayOrFunction(sourceVal)
+      ) {
         target[key] = _merge(targetVal, sourceVal);
       } else {
         target[key] = clone(sourceVal);
@@ -5624,24 +5640,24 @@
     if (!isObjectOrArrayOrFunction(target)) {
       target = {};
     }
+
     for (var i = 1, l = arguments.length; i < l; i++) {
       var source = arguments[i];
+
       if (isObjectOrArrayOrFunction(source)) {
         _merge(target, source);
       }
     }
     return target;
   }
-  module.exports = merge;
 
-  var merge$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null
-  });
+  var merge_1 = merge;
 
   // NOTE: this behaves like lodash/defaults, but doesn't mutate the target
   // it also preserve keys order
   var defaultsPure = function defaultsPure() {
     var sources = Array.prototype.slice.call(arguments);
+
     return sources.reduceRight(function (acc, source) {
       Object.keys(Object(source)).forEach(function (key) {
         if (source[key] === undefined) {
@@ -5659,7 +5675,10 @@
 
   function intersection(arr1, arr2) {
     return arr1.filter(function (value, index) {
-      return arr2.indexOf(value) > -1 && arr1.indexOf(value) === index /* skips duplicates */;
+      return (
+        arr2.indexOf(value) > -1 &&
+        arr1.indexOf(value) === index /* skips duplicates */
+      );
     });
   }
 
@@ -5670,11 +5689,13 @@
     if (!Array.isArray(array)) {
       return undefined;
     }
+
     for (var i = 0; i < array.length; i++) {
       if (comparator(array[i])) {
         return array[i];
       }
     }
+
     return undefined;
   };
 
@@ -5686,8 +5707,12 @@
     } else if (Array.isArray(v)) {
       return v.map(valToNumber);
     }
-    throw new Error('The value should be a number, a parsable string or an array of those.');
+
+    throw new Error(
+      'The value should be a number, a parsable string or an array of those.'
+    );
   }
+
   var valToNumber_1 = valToNumber;
 
   // https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620
@@ -5705,11 +5730,13 @@
     }
     return target;
   }
+
   var omit$1 = _objectWithoutPropertiesLoose$1;
 
   function objectHasKeys(obj) {
     return obj && Object.keys(obj).length > 0;
   }
+
   var objectHasKeys_1 = objectHasKeys;
 
   var isValidUserToken = function isValidUserToken(userToken) {
@@ -5733,6 +5760,8 @@
 
 
 
+
+
   var lib = {
     /**
      * Adds a refinement to a RefinementList
@@ -5745,10 +5774,17 @@
       if (lib.isRefined(refinementList, attribute, value)) {
         return refinementList;
       }
+
       var valueAsString = '' + value;
-      var facetRefinement = !refinementList[attribute] ? [valueAsString] : refinementList[attribute].concat(valueAsString);
+
+      var facetRefinement = !refinementList[attribute]
+        ? [valueAsString]
+        : refinementList[attribute].concat(valueAsString);
+
       var mod = {};
+
       mod[attribute] = facetRefinement;
+
       return defaultsPure({}, mod, refinementList);
     },
     /**
@@ -5760,7 +5796,11 @@
      * @param {string} [value] the value of the refinement
      * @return {RefinementList} a new and updated refinement lst
      */
-    removeRefinement: function removeRefinement(refinementList, attribute, value) {
+    removeRefinement: function removeRefinement(
+      refinementList,
+      attribute,
+      value
+    ) {
       if (value === undefined) {
         // we use the "filter" form of clearRefinement, since it leaves empty values as-is
         // the form with a string will remove the attribute completely
@@ -5768,7 +5808,9 @@
           return attribute === f;
         });
       }
+
       var valueAsString = '' + value;
+
       return lib.clearRefinement(refinementList, function (v, f) {
         return attribute === f && valueAsString === v;
       });
@@ -5780,11 +5822,18 @@
      * @param {string} value the value of the refinement
      * @return {RefinementList} a new and updated list
      */
-    toggleRefinement: function toggleRefinement(refinementList, attribute, value) {
-      if (value === undefined) throw new Error('toggleRefinement should be used with a value');
+    toggleRefinement: function toggleRefinement(
+      refinementList,
+      attribute,
+      value
+    ) {
+      if (value === undefined)
+        throw new Error('toggleRefinement should be used with a value');
+
       if (lib.isRefined(refinementList, attribute, value)) {
         return lib.removeRefinement(refinementList, attribute, value);
       }
+
       return lib.addRefinement(refinementList, attribute, value);
     },
     /**
@@ -5798,7 +5847,11 @@
      * @param {string} [refinementType] optional parameter to give more context to the attribute function
      * @return {RefinementList} a new and updated refinement list
      */
-    clearRefinement: function clearRefinement(refinementList, attribute, refinementType) {
+    clearRefinement: function clearRefinement(
+      refinementList,
+      attribute,
+      refinementType
+    ) {
       if (attribute === undefined) {
         // return the same object if the list is already empty
         // this is mainly for tests, as it doesn't have much impact on performance
@@ -5810,17 +5863,26 @@
         return omit$1(refinementList, [attribute]);
       } else if (typeof attribute === 'function') {
         var hasChanged = false;
-        var newRefinementList = Object.keys(refinementList).reduce(function (memo, key) {
+
+        var newRefinementList = Object.keys(refinementList).reduce(function (
+          memo,
+          key
+        ) {
           var values = refinementList[key] || [];
           var facetList = values.filter(function (value) {
             return !attribute(value, key, refinementType);
           });
+
           if (facetList.length !== values.length) {
             hasChanged = true;
           }
+
           memo[key] = facetList;
+
           return memo;
-        }, {});
+        },
+        {});
+
         if (hasChanged) return newRefinementList;
         return refinementList;
       }
@@ -5839,14 +5901,20 @@
      * @return {boolean} true if the attribute is refined, false otherwise
      */
     isRefined: function isRefined(refinementList, attribute, refinementValue) {
-      var containsRefinements = Boolean(refinementList[attribute]) && refinementList[attribute].length > 0;
+      var containsRefinements =
+        Boolean(refinementList[attribute]) &&
+        refinementList[attribute].length > 0;
+
       if (refinementValue === undefined || !containsRefinements) {
         return containsRefinements;
       }
+
       var refinementValueAsString = '' + refinementValue;
+
       return refinementList[attribute].indexOf(refinementValueAsString) !== -1;
-    }
+    },
   };
+
   var RefinementList = lib;
 
   /**
@@ -5861,9 +5929,12 @@
    */
   function isEqualNumericRefinement(a, b) {
     if (Array.isArray(a) && Array.isArray(b)) {
-      return a.length === b.length && a.every(function (el, i) {
-        return isEqualNumericRefinement(b[i], el);
-      });
+      return (
+        a.length === b.length &&
+        a.every(function (el, i) {
+          return isEqualNumericRefinement(b[i], el);
+        })
+      );
     }
     return a === b;
   }
@@ -5930,10 +6001,15 @@
   }
    */
   function SearchParameters(newParameters) {
-    var params = newParameters ? SearchParameters._parseNumbers(newParameters) : {};
+    var params = newParameters
+      ? SearchParameters._parseNumbers(newParameters)
+      : {};
+
     if (params.userToken !== undefined && !isValidUserToken(params.userToken)) {
       // eslint-disable-next-line no-console
-      console.warn('[algoliasearch-helper] The `userToken` parameter is invalid. This can lead to wrong analytics.\n  - Format: [a-zA-Z0-9_-]{1,64}');
+      console.warn(
+        '[algoliasearch-helper] The `userToken` parameter is invalid. This can lead to wrong analytics.\n  - Format: [a-zA-Z0-9_-]{1,64}'
+      );
     }
     /**
      * This attribute contains the list of all the conjunctive facets
@@ -6033,13 +6109,15 @@
      * be translated into the `facetFilters` attribute.
      * @member {Object.<string, SearchParameters.FacetList>}
      */
-    this.hierarchicalFacetsRefinements = params.hierarchicalFacetsRefinements || {};
+    this.hierarchicalFacetsRefinements =
+      params.hierarchicalFacetsRefinements || {};
 
     // eslint-disable-next-line consistent-this
     var self = this;
     Object.keys(params).forEach(function (paramName) {
       var isKeyKnown = SearchParameters.PARAMETERS.indexOf(paramName) !== -1;
       var isValueDefined = params[paramName] !== undefined;
+
       if (!isKeyKnown && isValueDefined) {
         self[paramName] = params[paramName];
       }
@@ -6061,8 +6139,23 @@
   SearchParameters._parseNumbers = function (partialState) {
     // Do not parse numbers again in SearchParameters, they ought to be parsed already
     if (partialState instanceof SearchParameters) return partialState;
+
     var numbers = {};
-    var numberKeys = ['aroundPrecision', 'aroundRadius', 'getRankingInfo', 'minWordSizefor2Typos', 'minWordSizefor1Typo', 'page', 'maxValuesPerFacet', 'distinct', 'minimumAroundRadius', 'hitsPerPage', 'minProximity'];
+
+    var numberKeys = [
+      'aroundPrecision',
+      'aroundRadius',
+      'getRankingInfo',
+      'minWordSizefor2Typos',
+      'minWordSizefor1Typo',
+      'page',
+      'maxValuesPerFacet',
+      'distinct',
+      'minimumAroundRadius',
+      'hitsPerPage',
+      'minProximity',
+    ];
+
     numberKeys.forEach(function (k) {
       var value = partialState[k];
       if (typeof value === 'string') {
@@ -6075,7 +6168,9 @@
     // there's two formats of insideBoundingBox, we need to parse
     // the one which is an array of float geo rectangles
     if (Array.isArray(partialState.insideBoundingBox)) {
-      numbers.insideBoundingBox = partialState.insideBoundingBox.map(function (geoRect) {
+      numbers.insideBoundingBox = partialState.insideBoundingBox.map(function (
+        geoRect
+      ) {
         if (Array.isArray(geoRect)) {
           return geoRect.map(function (value) {
             return parseFloat(value);
@@ -6084,6 +6179,7 @@
         return geoRect;
       });
     }
+
     if (partialState.numericRefinements) {
       var numericRefinements = {};
       Object.keys(partialState.numericRefinements).forEach(function (attribute) {
@@ -6109,7 +6205,8 @@
       });
       numbers.numericRefinements = numericRefinements;
     }
-    return merge$1({}, partialState, numbers);
+
+    return merge_1({}, partialState, numbers);
   };
 
   /**
@@ -6120,21 +6217,30 @@
    */
   SearchParameters.make = function makeSearchParameters(newParameters) {
     var instance = new SearchParameters(newParameters);
+
     var hierarchicalFacets = newParameters.hierarchicalFacets || [];
     hierarchicalFacets.forEach(function (facet) {
       if (facet.rootPath) {
         var currentRefinement = instance.getHierarchicalRefinement(facet.name);
-        if (currentRefinement.length > 0 && currentRefinement[0].indexOf(facet.rootPath) !== 0) {
+
+        if (
+          currentRefinement.length > 0 &&
+          currentRefinement[0].indexOf(facet.rootPath) !== 0
+        ) {
           instance = instance.clearRefinements(facet.name);
         }
 
         // get it again in case it has been cleared
         currentRefinement = instance.getHierarchicalRefinement(facet.name);
         if (currentRefinement.length === 0) {
-          instance = instance.toggleHierarchicalFacetRefinement(facet.name, facet.rootPath);
+          instance = instance.toggleHierarchicalFacetRefinement(
+            facet.name,
+            facet.rootPath
+          );
         }
       }
     });
+
     return instance;
   };
 
@@ -6146,22 +6252,51 @@
    */
   SearchParameters.validate = function (currentState, parameters) {
     var params = parameters || {};
-    if (currentState.tagFilters && params.tagRefinements && params.tagRefinements.length > 0) {
-      return new Error('[Tags] Cannot switch from the managed tag API to the advanced API. It is probably ' + 'an error, if it is really what you want, you should first clear the tags with clearTags method.');
+
+    if (
+      currentState.tagFilters &&
+      params.tagRefinements &&
+      params.tagRefinements.length > 0
+    ) {
+      return new Error(
+        '[Tags] Cannot switch from the managed tag API to the advanced API. It is probably ' +
+          'an error, if it is really what you want, you should first clear the tags with clearTags method.'
+      );
     }
+
     if (currentState.tagRefinements.length > 0 && params.tagFilters) {
-      return new Error('[Tags] Cannot switch from the advanced tag API to the managed API. It is probably ' + 'an error, if it is not, you should first clear the tags with clearTags method.');
+      return new Error(
+        '[Tags] Cannot switch from the advanced tag API to the managed API. It is probably ' +
+          'an error, if it is not, you should first clear the tags with clearTags method.'
+      );
     }
-    if (currentState.numericFilters && params.numericRefinements && objectHasKeys_1(params.numericRefinements)) {
-      return new Error("[Numeric filters] Can't switch from the advanced to the managed API. It" + ' is probably an error, if this is really what you want, you have to first' + ' clear the numeric filters.');
+
+    if (
+      currentState.numericFilters &&
+      params.numericRefinements &&
+      objectHasKeys_1(params.numericRefinements)
+    ) {
+      return new Error(
+        "[Numeric filters] Can't switch from the advanced to the managed API. It" +
+          ' is probably an error, if this is really what you want, you have to first' +
+          ' clear the numeric filters.'
+      );
     }
+
     if (objectHasKeys_1(currentState.numericRefinements) && params.numericFilters) {
-      return new Error("[Numeric filters] Can't switch from the managed API to the advanced. It" + ' is probably an error, if this is really what you want, you have to first' + ' clear the numeric filters.');
+      return new Error(
+        "[Numeric filters] Can't switch from the managed API to the advanced. It" +
+          ' is probably an error, if this is really what you want, you have to first' +
+          ' clear the numeric filters.'
+      );
     }
+
     return null;
   };
+
   SearchParameters.prototype = {
     constructor: SearchParameters,
+
     /**
      * Remove all refinements (disjunctive + conjunctive + excludes + numeric filters)
      * @method
@@ -6174,12 +6309,35 @@
     clearRefinements: function clearRefinements(attribute) {
       var patch = {
         numericRefinements: this._clearNumericRefinements(attribute),
-        facetsRefinements: RefinementList.clearRefinement(this.facetsRefinements, attribute, 'conjunctiveFacet'),
-        facetsExcludes: RefinementList.clearRefinement(this.facetsExcludes, attribute, 'exclude'),
-        disjunctiveFacetsRefinements: RefinementList.clearRefinement(this.disjunctiveFacetsRefinements, attribute, 'disjunctiveFacet'),
-        hierarchicalFacetsRefinements: RefinementList.clearRefinement(this.hierarchicalFacetsRefinements, attribute, 'hierarchicalFacet')
+        facetsRefinements: RefinementList.clearRefinement(
+          this.facetsRefinements,
+          attribute,
+          'conjunctiveFacet'
+        ),
+        facetsExcludes: RefinementList.clearRefinement(
+          this.facetsExcludes,
+          attribute,
+          'exclude'
+        ),
+        disjunctiveFacetsRefinements: RefinementList.clearRefinement(
+          this.disjunctiveFacetsRefinements,
+          attribute,
+          'disjunctiveFacet'
+        ),
+        hierarchicalFacetsRefinements: RefinementList.clearRefinement(
+          this.hierarchicalFacetsRefinements,
+          attribute,
+          'hierarchicalFacet'
+        ),
       };
-      if (patch.numericRefinements === this.numericRefinements && patch.facetsRefinements === this.facetsRefinements && patch.facetsExcludes === this.facetsExcludes && patch.disjunctiveFacetsRefinements === this.disjunctiveFacetsRefinements && patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements) {
+      if (
+        patch.numericRefinements === this.numericRefinements &&
+        patch.facetsRefinements === this.facetsRefinements &&
+        patch.facetsExcludes === this.facetsExcludes &&
+        patch.disjunctiveFacetsRefinements ===
+          this.disjunctiveFacetsRefinements &&
+        patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements
+      ) {
         return this;
       }
       return this.setQueryParameters(patch);
@@ -6190,10 +6348,12 @@
      * @return {SearchParameters} new instance with tags cleared
      */
     clearTags: function clearTags() {
-      if (this.tagFilters === undefined && this.tagRefinements.length === 0) return this;
+      if (this.tagFilters === undefined && this.tagRefinements.length === 0)
+        return this;
+
       return this.setQueryParameters({
         tagFilters: undefined,
-        tagRefinements: []
+        tagRefinements: [],
       });
     },
     /**
@@ -6204,8 +6364,9 @@
      */
     setIndex: function setIndex(index) {
       if (index === this.index) return this;
+
       return this.setQueryParameters({
-        index: index
+        index: index,
       });
     },
     /**
@@ -6216,8 +6377,9 @@
      */
     setQuery: function setQuery(newQuery) {
       if (newQuery === this.query) return this;
+
       return this.setQueryParameters({
-        query: newQuery
+        query: newQuery,
       });
     },
     /**
@@ -6228,8 +6390,9 @@
      */
     setPage: function setPage(newPage) {
       if (newPage === this.page) return this;
+
       return this.setQueryParameters({
-        page: newPage
+        page: newPage,
       });
     },
     /**
@@ -6241,7 +6404,7 @@
      */
     setFacets: function setFacets(facets) {
       return this.setQueryParameters({
-        facets: facets
+        facets: facets,
       });
     },
     /**
@@ -6253,7 +6416,7 @@
      */
     setDisjunctiveFacets: function setDisjunctiveFacets(facets) {
       return this.setQueryParameters({
-        disjunctiveFacets: facets
+        disjunctiveFacets: facets,
       });
     },
     /**
@@ -6265,8 +6428,9 @@
      */
     setHitsPerPage: function setHitsPerPage(n) {
       if (this.hitsPerPage === n) return this;
+
       return this.setQueryParameters({
-        hitsPerPage: n
+        hitsPerPage: n,
       });
     },
     /**
@@ -6278,8 +6442,9 @@
      */
     setTypoTolerance: function setTypoTolerance(typoTolerance) {
       if (this.typoTolerance === typoTolerance) return this;
+
       return this.setQueryParameters({
-        typoTolerance: typoTolerance
+        typoTolerance: typoTolerance,
       });
     },
     /**
@@ -6299,11 +6464,15 @@
      * state.addNumericRefinement('size', '=', 38);
      * state.addNumericRefinement('size', '=', 40);
      */
-    addNumericRefinement: function addNumericRefinement(attribute, operator, value) {
+    addNumericRefinement: function (attribute, operator, value) {
       var val = valToNumber_1(value);
+
       if (this.isNumericRefined(attribute, operator, val)) return this;
-      var mod = merge$1({}, this.numericRefinements);
-      mod[attribute] = merge$1({}, mod[attribute]);
+
+      var mod = merge_1({}, this.numericRefinements);
+
+      mod[attribute] = merge_1({}, mod[attribute]);
+
       if (mod[attribute][operator]) {
         // Array copy
         mod[attribute][operator] = mod[attribute][operator].slice();
@@ -6312,8 +6481,9 @@
       } else {
         mod[attribute][operator] = [val];
       }
+
       return this.setQueryParameters({
-        numericRefinements: mod
+        numericRefinements: mod,
       });
     },
     /**
@@ -6321,7 +6491,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getConjunctiveRefinements: function getConjunctiveRefinements(facetName) {
+    getConjunctiveRefinements: function (facetName) {
       if (!this.isConjunctiveFacet(facetName)) {
         return [];
       }
@@ -6332,7 +6502,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getDisjunctiveRefinements: function getDisjunctiveRefinements(facetName) {
+    getDisjunctiveRefinements: function (facetName) {
       if (!this.isDisjunctiveFacet(facetName)) {
         return [];
       }
@@ -6343,7 +6513,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getHierarchicalRefinement: function getHierarchicalRefinement(facetName) {
+    getHierarchicalRefinement: function (facetName) {
       // we send an array but we currently do not support multiple
       // hierarchicalRefinements for a hierarchicalFacet
       return this.hierarchicalFacetsRefinements[facetName] || [];
@@ -6353,12 +6523,13 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getExcludeRefinements: function getExcludeRefinements(facetName) {
+    getExcludeRefinements: function (facetName) {
       if (!this.isConjunctiveFacet(facetName)) {
         return [];
       }
       return this.facetsExcludes[facetName] || [];
     },
+
     /**
      * Remove all the numeric filter for a given (attribute, operator)
      * @method
@@ -6367,30 +6538,41 @@
      * @param {number} [number] the value to be removed
      * @return {SearchParameters} new instance
      */
-    removeNumericRefinement: function removeNumericRefinement(attribute, operator, number) {
+    removeNumericRefinement: function (attribute, operator, number) {
       var paramValue = number;
       if (paramValue !== undefined) {
         if (!this.isNumericRefined(attribute, operator, paramValue)) {
           return this;
         }
         return this.setQueryParameters({
-          numericRefinements: this._clearNumericRefinements(function (value, key) {
-            return key === attribute && value.op === operator && isEqualNumericRefinement(value.val, valToNumber_1(paramValue));
-          })
+          numericRefinements: this._clearNumericRefinements(function (
+            value,
+            key
+          ) {
+            return (
+              key === attribute &&
+              value.op === operator &&
+              isEqualNumericRefinement(value.val, valToNumber_1(paramValue))
+            );
+          }),
         });
       } else if (operator !== undefined) {
         if (!this.isNumericRefined(attribute, operator)) return this;
         return this.setQueryParameters({
-          numericRefinements: this._clearNumericRefinements(function (value, key) {
+          numericRefinements: this._clearNumericRefinements(function (
+            value,
+            key
+          ) {
             return key === attribute && value.op === operator;
-          })
+          }),
         });
       }
+
       if (!this.isNumericRefined(attribute)) return this;
       return this.setQueryParameters({
         numericRefinements: this._clearNumericRefinements(function (value, key) {
           return key === attribute;
-        })
+        }),
       });
     },
     /**
@@ -6398,7 +6580,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {SearchParameters.OperatorList} list of refinements
      */
-    getNumericRefinements: function getNumericRefinements(facetName) {
+    getNumericRefinements: function (facetName) {
       return this.numericRefinements[facetName] || {};
     },
     /**
@@ -6407,8 +6589,11 @@
      * @param {string} operator operator applied on the refined values
      * @return {Array.<number|number[]>} refined values
      */
-    getNumericRefinement: function getNumericRefinement(attribute, operator) {
-      return this.numericRefinements[attribute] && this.numericRefinements[attribute][operator];
+    getNumericRefinement: function (attribute, operator) {
+      return (
+        this.numericRefinements[attribute] &&
+        this.numericRefinements[attribute][operator]
+      );
     },
     /**
      * Clear numeric filters.
@@ -6431,28 +6616,36 @@
       } else if (typeof attribute === 'function') {
         var hasChanged = false;
         var numericRefinements = this.numericRefinements;
-        var newNumericRefinements = Object.keys(numericRefinements).reduce(function (memo, key) {
-          var operators = numericRefinements[key];
-          var operatorList = {};
-          operators = operators || {};
-          Object.keys(operators).forEach(function (operator) {
-            var values = operators[operator] || [];
-            var outValues = [];
-            values.forEach(function (value) {
-              var predicateResult = attribute({
-                val: value,
-                op: operator
-              }, key, 'numeric');
-              if (!predicateResult) outValues.push(value);
+        var newNumericRefinements = Object.keys(numericRefinements).reduce(
+          function (memo, key) {
+            var operators = numericRefinements[key];
+            var operatorList = {};
+
+            operators = operators || {};
+            Object.keys(operators).forEach(function (operator) {
+              var values = operators[operator] || [];
+              var outValues = [];
+              values.forEach(function (value) {
+                var predicateResult = attribute(
+                  { val: value, op: operator },
+                  key,
+                  'numeric'
+                );
+                if (!predicateResult) outValues.push(value);
+              });
+              if (outValues.length !== values.length) {
+                hasChanged = true;
+              }
+              operatorList[operator] = outValues;
             });
-            if (outValues.length !== values.length) {
-              hasChanged = true;
-            }
-            operatorList[operator] = outValues;
-          });
-          memo[key] = operatorList;
-          return memo;
-        }, {});
+
+            memo[key] = operatorList;
+
+            return memo;
+          },
+          {}
+        );
+
         if (hasChanged) return newNumericRefinements;
         return this.numericRefinements;
       }
@@ -6472,8 +6665,9 @@
       if (this.isConjunctiveFacet(facet)) {
         return this;
       }
+
       return this.setQueryParameters({
-        facets: this.facets.concat([facet])
+        facets: this.facets.concat([facet]),
       });
     },
     /**
@@ -6487,8 +6681,9 @@
       if (this.isDisjunctiveFacet(facet)) {
         return this;
       }
+
       return this.setQueryParameters({
-        disjunctiveFacets: this.disjunctiveFacets.concat([facet])
+        disjunctiveFacets: this.disjunctiveFacets.concat([facet]),
       });
     },
     /**
@@ -6501,10 +6696,15 @@
      */
     addHierarchicalFacet: function addHierarchicalFacet(hierarchicalFacet) {
       if (this.isHierarchicalFacet(hierarchicalFacet.name)) {
-        throw new Error('Cannot declare two hierarchical facets with the same name: `' + hierarchicalFacet.name + '`');
+        throw new Error(
+          'Cannot declare two hierarchical facets with the same name: `' +
+            hierarchicalFacet.name +
+            '`'
+        );
       }
+
       return this.setQueryParameters({
-        hierarchicalFacets: this.hierarchicalFacets.concat([hierarchicalFacet])
+        hierarchicalFacets: this.hierarchicalFacets.concat([hierarchicalFacet]),
       });
     },
     /**
@@ -6516,11 +6716,20 @@
      */
     addFacetRefinement: function addFacetRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
-      if (RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
+      if (RefinementList.isRefined(this.facetsRefinements, facet, value))
+        return this;
+
       return this.setQueryParameters({
-        facetsRefinements: RefinementList.addRefinement(this.facetsRefinements, facet, value)
+        facetsRefinements: RefinementList.addRefinement(
+          this.facetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6532,11 +6741,20 @@
      */
     addExcludeRefinement: function addExcludeRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
-      if (RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
+      if (RefinementList.isRefined(this.facetsExcludes, facet, value))
+        return this;
+
       return this.setQueryParameters({
-        facetsExcludes: RefinementList.addRefinement(this.facetsExcludes, facet, value)
+        facetsExcludes: RefinementList.addRefinement(
+          this.facetsExcludes,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6546,13 +6764,28 @@
      * @param {string} value value of the attribute (will be converted to string)
      * @return {SearchParameters} new instance
      */
-    addDisjunctiveFacetRefinement: function addDisjunctiveFacetRefinement(facet, value) {
+    addDisjunctiveFacetRefinement: function addDisjunctiveFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isDisjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the disjunctiveFacets attribute of the helper configuration'
+        );
       }
-      if (RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;
+
+      if (
+        RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)
+      )
+        return this;
+
       return this.setQueryParameters({
-        disjunctiveFacetsRefinements: RefinementList.addRefinement(this.disjunctiveFacetsRefinements, facet, value)
+        disjunctiveFacetsRefinements: RefinementList.addRefinement(
+          this.disjunctiveFacetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6562,9 +6795,11 @@
      */
     addTagRefinement: function addTagRefinement(tag) {
       if (this.isTagRefined(tag)) return this;
+
       var modification = {
-        tagRefinements: this.tagRefinements.concat(tag)
+        tagRefinements: this.tagRefinements.concat(tag),
       };
+
       return this.setQueryParameters(modification);
     },
     /**
@@ -6578,10 +6813,11 @@
       if (!this.isConjunctiveFacet(facet)) {
         return this;
       }
+
       return this.clearRefinements(facet).setQueryParameters({
         facets: this.facets.filter(function (f) {
           return f !== facet;
-        })
+        }),
       });
     },
     /**
@@ -6595,10 +6831,11 @@
       if (!this.isDisjunctiveFacet(facet)) {
         return this;
       }
+
       return this.clearRefinements(facet).setQueryParameters({
         disjunctiveFacets: this.disjunctiveFacets.filter(function (f) {
           return f !== facet;
-        })
+        }),
       });
     },
     /**
@@ -6612,10 +6849,11 @@
       if (!this.isHierarchicalFacet(facet)) {
         return this;
       }
+
       return this.clearRefinements(facet).setQueryParameters({
         hierarchicalFacets: this.hierarchicalFacets.filter(function (f) {
           return f.name !== facet;
-        })
+        }),
       });
     },
     /**
@@ -6629,11 +6867,20 @@
      */
     removeFacetRefinement: function removeFacetRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
-      if (!RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
+      if (!RefinementList.isRefined(this.facetsRefinements, facet, value))
+        return this;
+
       return this.setQueryParameters({
-        facetsRefinements: RefinementList.removeRefinement(this.facetsRefinements, facet, value)
+        facetsRefinements: RefinementList.removeRefinement(
+          this.facetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6645,11 +6892,20 @@
      */
     removeExcludeRefinement: function removeExcludeRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
-      if (!RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
+      if (!RefinementList.isRefined(this.facetsExcludes, facet, value))
+        return this;
+
       return this.setQueryParameters({
-        facetsExcludes: RefinementList.removeRefinement(this.facetsExcludes, facet, value)
+        facetsExcludes: RefinementList.removeRefinement(
+          this.facetsExcludes,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6659,13 +6915,27 @@
      * @param {string} value value used to filter
      * @return {SearchParameters} new instance
      */
-    removeDisjunctiveFacetRefinement: function removeDisjunctiveFacetRefinement(facet, value) {
+    removeDisjunctiveFacetRefinement: function removeDisjunctiveFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isDisjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the disjunctiveFacets attribute of the helper configuration'
+        );
       }
-      if (!RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;
+      if (
+        !RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)
+      )
+        return this;
+
       return this.setQueryParameters({
-        disjunctiveFacetsRefinements: RefinementList.removeRefinement(this.disjunctiveFacetsRefinements, facet, value)
+        disjunctiveFacetsRefinements: RefinementList.removeRefinement(
+          this.disjunctiveFacetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6676,11 +6946,13 @@
      */
     removeTagRefinement: function removeTagRefinement(tag) {
       if (!this.isTagRefined(tag)) return this;
+
       var modification = {
         tagRefinements: this.tagRefinements.filter(function (t) {
           return t !== tag;
-        })
+        }),
       };
+
       return this.setQueryParameters(modification);
     },
     /**
@@ -6711,7 +6983,12 @@
       } else if (this.isDisjunctiveFacet(facet)) {
         return this.toggleDisjunctiveFacetRefinement(facet, value);
       }
-      throw new Error('Cannot refine the undeclared facet ' + facet + '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets');
+
+      throw new Error(
+        'Cannot refine the undeclared facet ' +
+          facet +
+          '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets'
+      );
     },
     /**
      * Switch the refinement applied over a facet/value
@@ -6720,12 +6997,23 @@
      * @param {value} value value used for filtering
      * @return {SearchParameters} new instance
      */
-    toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(facet, value) {
+    toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
+
       return this.setQueryParameters({
-        facetsRefinements: RefinementList.toggleRefinement(this.facetsRefinements, facet, value)
+        facetsRefinements: RefinementList.toggleRefinement(
+          this.facetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6735,12 +7023,23 @@
      * @param {value} value value used for filtering
      * @return {SearchParameters} new instance
      */
-    toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(facet, value) {
+    toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
+
       return this.setQueryParameters({
-        facetsExcludes: RefinementList.toggleRefinement(this.facetsExcludes, facet, value)
+        facetsExcludes: RefinementList.toggleRefinement(
+          this.facetsExcludes,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6750,12 +7049,23 @@
      * @param {value} value value used for filtering
      * @return {SearchParameters} new instance
      */
-    toggleDisjunctiveFacetRefinement: function toggleDisjunctiveFacetRefinement(facet, value) {
+    toggleDisjunctiveFacetRefinement: function toggleDisjunctiveFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isDisjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the disjunctiveFacets attribute of the helper configuration'
+        );
       }
+
       return this.setQueryParameters({
-        disjunctiveFacetsRefinements: RefinementList.toggleRefinement(this.disjunctiveFacetsRefinements, facet, value)
+        disjunctiveFacetsRefinements: RefinementList.toggleRefinement(
+          this.disjunctiveFacetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6765,21 +7075,37 @@
      * @param {value} value value used for filtering
      * @return {SearchParameters} new instance
      */
-    toggleHierarchicalFacetRefinement: function toggleHierarchicalFacetRefinement(facet, value) {
+    toggleHierarchicalFacetRefinement: function toggleHierarchicalFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isHierarchicalFacet(facet)) {
-        throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the hierarchicalFacets attribute of the helper configuration'
+        );
       }
-      var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facet));
+
+      var separator = this._getHierarchicalFacetSeparator(
+        this.getHierarchicalFacetByName(facet)
+      );
+
       var mod = {};
-      var upOneOrMultipleLevel = this.hierarchicalFacetsRefinements[facet] !== undefined && this.hierarchicalFacetsRefinements[facet].length > 0 && (
-      // remove current refinement:
-      // refinement was 'beer > IPA', call is toggleRefine('beer > IPA'), refinement should be `beer`
-      this.hierarchicalFacetsRefinements[facet][0] === value ||
-      // remove a parent refinement of the current refinement:
-      //  - refinement was 'beer > IPA > Flying dog'
-      //  - call is toggleRefine('beer > IPA')
-      //  - refinement should be `beer`
-      this.hierarchicalFacetsRefinements[facet][0].indexOf(value + separator) === 0);
+
+      var upOneOrMultipleLevel =
+        this.hierarchicalFacetsRefinements[facet] !== undefined &&
+        this.hierarchicalFacetsRefinements[facet].length > 0 &&
+        // remove current refinement:
+        // refinement was 'beer > IPA', call is toggleRefine('beer > IPA'), refinement should be `beer`
+        (this.hierarchicalFacetsRefinements[facet][0] === value ||
+          // remove a parent refinement of the current refinement:
+          //  - refinement was 'beer > IPA > Flying dog'
+          //  - call is toggleRefine('beer > IPA')
+          //  - refinement should be `beer`
+          this.hierarchicalFacetsRefinements[facet][0].indexOf(
+            value + separator
+          ) === 0);
+
       if (upOneOrMultipleLevel) {
         if (value.indexOf(separator) === -1) {
           // go back to root level
@@ -6790,10 +7116,16 @@
       } else {
         mod[facet] = [value];
       }
+
       return this.setQueryParameters({
-        hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)
+        hierarchicalFacetsRefinements: defaultsPure(
+          {},
+          mod,
+          this.hierarchicalFacetsRefinements
+        ),
       });
     },
+
     /**
      * Adds a refinement on a hierarchical facet.
      * @param {string} facet the facet name
@@ -6801,33 +7133,45 @@
      * @return {SearchParameter} the new state
      * @throws Error if the facet is not defined or if the facet is refined
      */
-    addHierarchicalFacetRefinement: function addHierarchicalFacetRefinement(facet, path) {
+    addHierarchicalFacetRefinement: function (facet, path) {
       if (this.isHierarchicalFacetRefined(facet)) {
         throw new Error(facet + ' is already refined.');
       }
       if (!this.isHierarchicalFacet(facet)) {
-        throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration.');
+        throw new Error(
+          facet +
+            ' is not defined in the hierarchicalFacets attribute of the helper configuration.'
+        );
       }
       var mod = {};
       mod[facet] = [path];
       return this.setQueryParameters({
-        hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)
+        hierarchicalFacetsRefinements: defaultsPure(
+          {},
+          mod,
+          this.hierarchicalFacetsRefinements
+        ),
       });
     },
+
     /**
      * Removes the refinement set on a hierarchical facet.
      * @param {string} facet the facet name
      * @return {SearchParameter} the new state
      * @throws Error if the facet is not defined or if the facet is not refined
      */
-    removeHierarchicalFacetRefinement: function removeHierarchicalFacetRefinement(facet) {
+    removeHierarchicalFacetRefinement: function (facet) {
       if (!this.isHierarchicalFacetRefined(facet)) {
         return this;
       }
       var mod = {};
       mod[facet] = [];
       return this.setQueryParameters({
-        hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)
+        hierarchicalFacetsRefinements: defaultsPure(
+          {},
+          mod,
+          this.hierarchicalFacetsRefinements
+        ),
       });
     },
     /**
@@ -6840,6 +7184,7 @@
       if (this.isTagRefined(tag)) {
         return this.removeTagRefinement(tag);
       }
+
       return this.addTagRefinement(tag);
     },
     /**
@@ -6848,7 +7193,7 @@
      * @param {string} facet facet name to test
      * @return {boolean} true if facet is a disjunctive facet
      */
-    isDisjunctiveFacet: function isDisjunctiveFacet(facet) {
+    isDisjunctiveFacet: function (facet) {
       return this.disjunctiveFacets.indexOf(facet) > -1;
     },
     /**
@@ -6857,7 +7202,7 @@
      * @param {string} facetName facet name to test
      * @return {boolean} true if facetName is a hierarchical facet
      */
-    isHierarchicalFacet: function isHierarchicalFacet(facetName) {
+    isHierarchicalFacet: function (facetName) {
       return this.getHierarchicalFacetByName(facetName) !== undefined;
     },
     /**
@@ -6866,7 +7211,7 @@
      * @param {string} facet facet name to test
      * @return {boolean} true if facet is a conjunctive facet
      */
-    isConjunctiveFacet: function isConjunctiveFacet(facet) {
+    isConjunctiveFacet: function (facet) {
       return this.facets.indexOf(facet) > -1;
     },
     /**
@@ -6913,7 +7258,11 @@
       if (!this.isDisjunctiveFacet(facet)) {
         return false;
       }
-      return RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value);
+      return RefinementList.isRefined(
+        this.disjunctiveFacetsRefinements,
+        facet,
+        value
+      );
     },
     /**
      * Returns true if the facet contains a refinement, or if a value passed is a
@@ -6924,14 +7273,20 @@
      * if there is one, otherwise will test if the facet contains any refinement
      * @return {boolean} true if the facet is refined
      */
-    isHierarchicalFacetRefined: function isHierarchicalFacetRefined(facet, value) {
+    isHierarchicalFacetRefined: function isHierarchicalFacetRefined(
+      facet,
+      value
+    ) {
       if (!this.isHierarchicalFacet(facet)) {
         return false;
       }
+
       var refinements = this.getHierarchicalRefinement(facet);
+
       if (!value) {
         return refinements.length > 0;
       }
+
       return refinements.indexOf(value) !== -1;
     },
     /**
@@ -6948,12 +7303,20 @@
       if (value === undefined && operator === undefined) {
         return Boolean(this.numericRefinements[attribute]);
       }
-      var isOperatorDefined = this.numericRefinements[attribute] && this.numericRefinements[attribute][operator] !== undefined;
+
+      var isOperatorDefined =
+        this.numericRefinements[attribute] &&
+        this.numericRefinements[attribute][operator] !== undefined;
+
       if (value === undefined || !isOperatorDefined) {
         return isOperatorDefined;
       }
+
       var parsedValue = valToNumber_1(value);
-      var isAttributeValueDefined = findArray(this.numericRefinements[attribute][operator], parsedValue) !== undefined;
+      var isAttributeValueDefined =
+        findArray(this.numericRefinements[attribute][operator], parsedValue) !==
+        undefined;
+
       return isOperatorDefined && isAttributeValueDefined;
     },
     /**
@@ -6977,12 +7340,19 @@
       var self = this;
 
       // attributes used for numeric filter can also be disjunctive
-      var disjunctiveNumericRefinedFacets = intersection_1(Object.keys(this.numericRefinements).filter(function (facet) {
-        return Object.keys(self.numericRefinements[facet]).length > 0;
-      }), this.disjunctiveFacets);
-      return Object.keys(this.disjunctiveFacetsRefinements).filter(function (facet) {
-        return self.disjunctiveFacetsRefinements[facet].length > 0;
-      }).concat(disjunctiveNumericRefinedFacets).concat(this.getRefinedHierarchicalFacets());
+      var disjunctiveNumericRefinedFacets = intersection_1(
+        Object.keys(this.numericRefinements).filter(function (facet) {
+          return Object.keys(self.numericRefinements[facet]).length > 0;
+        }),
+        this.disjunctiveFacets
+      );
+
+      return Object.keys(this.disjunctiveFacetsRefinements)
+        .filter(function (facet) {
+          return self.disjunctiveFacetsRefinements[facet].length > 0;
+        })
+        .concat(disjunctiveNumericRefinedFacets)
+        .concat(this.getRefinedHierarchicalFacets());
     },
     /**
      * Returns the list of all disjunctive facets refined
@@ -6995,38 +7365,61 @@
       // eslint-disable-next-line consistent-this
       var self = this;
       return intersection_1(
-      // enforce the order between the two arrays,
-      // so that refinement name index === hierarchical facet index
-      this.hierarchicalFacets.map(function (facet) {
-        return facet.name;
-      }), Object.keys(this.hierarchicalFacetsRefinements).filter(function (facet) {
-        return self.hierarchicalFacetsRefinements[facet].length > 0;
-      }));
+        // enforce the order between the two arrays,
+        // so that refinement name index === hierarchical facet index
+        this.hierarchicalFacets.map(function (facet) {
+          return facet.name;
+        }),
+        Object.keys(this.hierarchicalFacetsRefinements).filter(function (facet) {
+          return self.hierarchicalFacetsRefinements[facet].length > 0;
+        })
+      );
     },
     /**
      * Returned the list of all disjunctive facets not refined
      * @method
      * @return {string[]} returns the list of facets that are not refined
      */
-    getUnrefinedDisjunctiveFacets: function getUnrefinedDisjunctiveFacets() {
+    getUnrefinedDisjunctiveFacets: function () {
       var refinedFacets = this.getRefinedDisjunctiveFacets();
+
       return this.disjunctiveFacets.filter(function (f) {
         return refinedFacets.indexOf(f) === -1;
       });
     },
-    managedParameters: ['index', 'facets', 'disjunctiveFacets', 'facetsRefinements', 'hierarchicalFacets', 'facetsExcludes', 'disjunctiveFacetsRefinements', 'numericRefinements', 'tagRefinements', 'hierarchicalFacetsRefinements'],
+
+    managedParameters: [
+      'index',
+
+      'facets',
+      'disjunctiveFacets',
+      'facetsRefinements',
+      'hierarchicalFacets',
+      'facetsExcludes',
+
+      'disjunctiveFacetsRefinements',
+      'numericRefinements',
+      'tagRefinements',
+      'hierarchicalFacetsRefinements',
+    ],
+
     getQueryParams: function getQueryParams() {
       var managedParameters = this.managedParameters;
+
       var queryParams = {};
 
       // eslint-disable-next-line consistent-this
       var self = this;
       Object.keys(this).forEach(function (paramName) {
         var paramValue = self[paramName];
-        if (managedParameters.indexOf(paramName) === -1 && paramValue !== undefined) {
+        if (
+          managedParameters.indexOf(paramName) === -1 &&
+          paramValue !== undefined
+        ) {
           queryParams[paramName] = paramValue;
         }
       });
+
       return queryParams;
     },
     /**
@@ -7041,8 +7434,11 @@
      */
     setQueryParameter: function setParameter(parameter, value) {
       if (this[parameter] === value) return this;
+
       var modification = {};
+
       modification[parameter] = value;
+
       return this.setQueryParameters(modification);
     },
     /**
@@ -7053,7 +7449,9 @@
      */
     setQueryParameters: function setQueryParameters(params) {
       if (!params) return this;
+
       var error = SearchParameters.validate(this, params);
+
       if (error) {
         throw error;
       }
@@ -7065,99 +7463,121 @@
         acc[key] = self[key];
         return acc;
       }, {});
-      var nextPlainObject = Object.keys(nextWithNumbers).reduce(function (previous, key) {
+
+      var nextPlainObject = Object.keys(nextWithNumbers).reduce(function (
+        previous,
+        key
+      ) {
         var isPreviousValueDefined = previous[key] !== undefined;
         var isNextValueDefined = nextWithNumbers[key] !== undefined;
+
         if (isPreviousValueDefined && !isNextValueDefined) {
           return omit$1(previous, [key]);
         }
+
         if (isNextValueDefined) {
           previous[key] = nextWithNumbers[key];
         }
+
         return previous;
-      }, previousPlainObject);
+      },
+      previousPlainObject);
+
       return new this.constructor(nextPlainObject);
     },
+
     /**
      * Returns a new instance with the page reset. Two scenarios possible:
      * the page is omitted -> return the given instance
      * the page is set -> return a new instance with a page of 0
      * @return {SearchParameters} a new updated instance
      */
-    resetPage: function resetPage() {
+    resetPage: function () {
       if (this.page === undefined) {
         return this;
       }
+
       return this.setPage(0);
     },
+
     /**
      * Helper function to get the hierarchicalFacet separator or the default one (`>`)
      * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.separator or `>` as default
      */
-    _getHierarchicalFacetSortBy: function _getHierarchicalFacetSortBy(hierarchicalFacet) {
+    _getHierarchicalFacetSortBy: function (hierarchicalFacet) {
       return hierarchicalFacet.sortBy || ['isRefined:desc', 'name:asc'];
     },
+
     /**
      * Helper function to get the hierarchicalFacet separator or the default one (`>`)
      * @private
      * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.separator or `>` as default
      */
-    _getHierarchicalFacetSeparator: function _getHierarchicalFacetSeparator(hierarchicalFacet) {
+    _getHierarchicalFacetSeparator: function (hierarchicalFacet) {
       return hierarchicalFacet.separator || ' > ';
     },
+
     /**
      * Helper function to get the hierarchicalFacet prefix path or null
      * @private
      * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.rootPath or null as default
      */
-    _getHierarchicalRootPath: function _getHierarchicalRootPath(hierarchicalFacet) {
+    _getHierarchicalRootPath: function (hierarchicalFacet) {
       return hierarchicalFacet.rootPath || null;
     },
+
     /**
      * Helper function to check if we show the parent level of the hierarchicalFacet
      * @private
      * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.showParentLevel or true as default
      */
-    _getHierarchicalShowParentLevel: function _getHierarchicalShowParentLevel(hierarchicalFacet) {
+    _getHierarchicalShowParentLevel: function (hierarchicalFacet) {
       if (typeof hierarchicalFacet.showParentLevel === 'boolean') {
         return hierarchicalFacet.showParentLevel;
       }
       return true;
     },
+
     /**
      * Helper function to get the hierarchicalFacet by it's name
      * @param  {string} hierarchicalFacetName the hierarchicalFacet name
      * @return {object} a hierarchicalFacet
      */
-    getHierarchicalFacetByName: function getHierarchicalFacetByName(hierarchicalFacetName) {
+    getHierarchicalFacetByName: function (hierarchicalFacetName) {
       return find$1(this.hierarchicalFacets, function (f) {
         return f.name === hierarchicalFacetName;
       });
     },
+
     /**
      * Get the current breadcrumb for a hierarchical facet, as an array
      * @param  {string} facetName Hierarchical facet name
      * @return {array.<string>} the path as an array of string
      */
-    getHierarchicalFacetBreadcrumb: function getHierarchicalFacetBreadcrumb(facetName) {
+    getHierarchicalFacetBreadcrumb: function (facetName) {
       if (!this.isHierarchicalFacet(facetName)) {
         return [];
       }
+
       var refinement = this.getHierarchicalRefinement(facetName)[0];
       if (!refinement) return [];
-      var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facetName));
+
+      var separator = this._getHierarchicalFacetSeparator(
+        this.getHierarchicalFacetByName(facetName)
+      );
       var path = refinement.split(separator);
       return path.map(function (part) {
         return part.trim();
       });
     },
-    toString: function toString() {
+
+    toString: function () {
       return JSON.stringify(this, null, 2);
-    }
+    },
   };
 
   /**
@@ -7175,12 +7595,22 @@
     if (value !== other) {
       var valIsDefined = value !== undefined;
       var valIsNull = value === null;
+
       var othIsDefined = other !== undefined;
       var othIsNull = other === null;
-      if (!othIsNull && value > other || valIsNull && othIsDefined || !valIsDefined) {
+
+      if (
+        (!othIsNull && value > other) ||
+        (valIsNull && othIsDefined) ||
+        !valIsDefined
+      ) {
         return 1;
       }
-      if (!valIsNull && value < other || othIsNull && valIsDefined || !othIsDefined) {
+      if (
+        (!valIsNull && value < other) ||
+        (othIsNull && valIsDefined) ||
+        !othIsDefined
+      ) {
         return -1;
       }
     }
@@ -7197,20 +7627,24 @@
     if (!Array.isArray(collection)) {
       return [];
     }
+
     if (!Array.isArray(orders)) {
       orders = [];
     }
+
     var result = collection.map(function (value, index) {
       return {
         criteria: iteratees.map(function (iteratee) {
           return value[iteratee];
         }),
         index: index,
-        value: value
+        value: value,
       };
     });
+
     result.sort(function comparer(object, other) {
       var index = -1;
+
       while (++index < object.criteria.length) {
         var res = compareAscending(object.criteria[index], other.criteria[index]);
         if (res) {
@@ -7228,16 +7662,19 @@
       // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
       return object.index - other.index;
     });
+
     return result.map(function (res) {
       return res.value;
     });
   }
+
   var orderBy_1 = orderBy;
 
   var compact = function compact(array) {
     if (!Array.isArray(array)) {
       return [];
     }
+
     return array.filter(Boolean);
   };
 
@@ -7246,6 +7683,7 @@
     if (!Array.isArray(array)) {
       return -1;
     }
+
     for (var i = 0; i < array.length; i++) {
       if (comparator(array[i])) {
         return i;
@@ -7264,20 +7702,30 @@
     var defaultInstructions = (defaults || []).map(function (sort) {
       return sort.split(':');
     });
-    return sortBy.reduce(function preparePredicate(out, sort) {
-      var sortInstruction = sort.split(':');
-      var matchingDefault = find$1(defaultInstructions, function (defaultInstruction) {
-        return defaultInstruction[0] === sortInstruction[0];
-      });
-      if (sortInstruction.length > 1 || !matchingDefault) {
-        out[0].push(sortInstruction[0]);
-        out[1].push(sortInstruction[1]);
+
+    return sortBy.reduce(
+      function preparePredicate(out, sort) {
+        var sortInstruction = sort.split(':');
+
+        var matchingDefault = find$1(
+          defaultInstructions,
+          function (defaultInstruction) {
+            return defaultInstruction[0] === sortInstruction[0];
+          }
+        );
+
+        if (sortInstruction.length > 1 || !matchingDefault) {
+          out[0].push(sortInstruction[0]);
+          out[1].push(sortInstruction[1]);
+          return out;
+        }
+
+        out[0].push(matchingDefault[0]);
+        out[1].push(matchingDefault[1]);
         return out;
-      }
-      out[0].push(matchingDefault[0]);
-      out[1].push(matchingDefault[1]);
-      return out;
-    }, [[], []]);
+      },
+      [[], []]
+    );
   };
 
   /**
@@ -7288,6 +7736,7 @@
    */
   function escapeFacetValue$1(value) {
     if (typeof value !== 'string') return value;
+
     return String(value).replace(/^-/, '\\-');
   }
 
@@ -7299,11 +7748,13 @@
    */
   function unescapeFacetValue$1(value) {
     if (typeof value !== 'string') return value;
+
     return value.replace(/^\\-/, '-');
   }
+
   var escapeFacetValue_1 = {
     escapeFacetValue: escapeFacetValue$1,
-    unescapeFacetValue: unescapeFacetValue$1
+    unescapeFacetValue: unescapeFacetValue$1,
   };
 
   var generateHierarchicalTree_1 = generateTrees;
@@ -7311,44 +7762,78 @@
 
 
 
+
   var escapeFacetValue$2 = escapeFacetValue_1.escapeFacetValue;
   var unescapeFacetValue$2 = escapeFacetValue_1.unescapeFacetValue;
+
   function generateTrees(state) {
     return function generate(hierarchicalFacetResult, hierarchicalFacetIndex) {
       var hierarchicalFacet = state.hierarchicalFacets[hierarchicalFacetIndex];
-      var hierarchicalFacetRefinement = state.hierarchicalFacetsRefinements[hierarchicalFacet.name] && state.hierarchicalFacetsRefinements[hierarchicalFacet.name][0] || '';
-      var hierarchicalSeparator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
-      var hierarchicalRootPath = state._getHierarchicalRootPath(hierarchicalFacet);
-      var hierarchicalShowParentLevel = state._getHierarchicalShowParentLevel(hierarchicalFacet);
-      var sortBy = formatSort(state._getHierarchicalFacetSortBy(hierarchicalFacet));
+      var hierarchicalFacetRefinement =
+        (state.hierarchicalFacetsRefinements[hierarchicalFacet.name] &&
+          state.hierarchicalFacetsRefinements[hierarchicalFacet.name][0]) ||
+        '';
+      var hierarchicalSeparator =
+        state._getHierarchicalFacetSeparator(hierarchicalFacet);
+      var hierarchicalRootPath =
+        state._getHierarchicalRootPath(hierarchicalFacet);
+      var hierarchicalShowParentLevel =
+        state._getHierarchicalShowParentLevel(hierarchicalFacet);
+      var sortBy = formatSort(
+        state._getHierarchicalFacetSortBy(hierarchicalFacet)
+      );
+
       var rootExhaustive = hierarchicalFacetResult.every(function (facetResult) {
         return facetResult.exhaustive;
       });
-      var generateTreeFn = generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, hierarchicalFacetRefinement);
+
+      var generateTreeFn = generateHierarchicalTree(
+        sortBy,
+        hierarchicalSeparator,
+        hierarchicalRootPath,
+        hierarchicalShowParentLevel,
+        hierarchicalFacetRefinement
+      );
+
       var results = hierarchicalFacetResult;
+
       if (hierarchicalRootPath) {
-        results = hierarchicalFacetResult.slice(hierarchicalRootPath.split(hierarchicalSeparator).length);
+        results = hierarchicalFacetResult.slice(
+          hierarchicalRootPath.split(hierarchicalSeparator).length
+        );
       }
+
       return results.reduce(generateTreeFn, {
         name: state.hierarchicalFacets[hierarchicalFacetIndex].name,
-        count: null,
-        // root level, no count
-        isRefined: true,
-        // root level, always refined
-        path: null,
-        // root level, no path
+        count: null, // root level, no count
+        isRefined: true, // root level, always refined
+        path: null, // root level, no path
         escapedValue: null,
         exhaustive: rootExhaustive,
-        data: null
+        data: null,
       });
     };
   }
-  function generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, currentRefinement) {
-    return function generateTree(hierarchicalTree, hierarchicalFacetResult, currentHierarchicalLevel) {
+
+  function generateHierarchicalTree(
+    sortBy,
+    hierarchicalSeparator,
+    hierarchicalRootPath,
+    hierarchicalShowParentLevel,
+    currentRefinement
+  ) {
+    return function generateTree(
+      hierarchicalTree,
+      hierarchicalFacetResult,
+      currentHierarchicalLevel
+    ) {
       var parent = hierarchicalTree;
+
       if (currentHierarchicalLevel > 0) {
         var level = 0;
+
         parent = hierarchicalTree;
+
         while (level < currentHierarchicalLevel) {
           /**
            * @type {object[]]} hierarchical data
@@ -7374,51 +7859,102 @@
         // If parent refinement is `beers`, then we do not want to have `bières > Belges`
         // showing up
 
-        var picked = Object.keys(hierarchicalFacetResult.data).map(function (facetValue) {
-          return [facetValue, hierarchicalFacetResult.data[facetValue]];
-        }).filter(function (tuple) {
-          var facetValue = tuple[0];
-          return onlyMatchingTree(facetValue, parent.path || hierarchicalRootPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel);
-        });
-        parent.data = orderBy_1(picked.map(function (tuple) {
-          var facetValue = tuple[0];
-          var facetCount = tuple[1];
-          return format(facetCount, facetValue, hierarchicalSeparator, unescapeFacetValue$2(currentRefinement), hierarchicalFacetResult.exhaustive);
-        }), sortBy[0], sortBy[1]);
+        var picked = Object.keys(hierarchicalFacetResult.data)
+          .map(function (facetValue) {
+            return [facetValue, hierarchicalFacetResult.data[facetValue]];
+          })
+          .filter(function (tuple) {
+            var facetValue = tuple[0];
+            return onlyMatchingTree(
+              facetValue,
+              parent.path || hierarchicalRootPath,
+              currentRefinement,
+              hierarchicalSeparator,
+              hierarchicalRootPath,
+              hierarchicalShowParentLevel
+            );
+          });
+
+        parent.data = orderBy_1(
+          picked.map(function (tuple) {
+            var facetValue = tuple[0];
+            var facetCount = tuple[1];
+
+            return format(
+              facetCount,
+              facetValue,
+              hierarchicalSeparator,
+              unescapeFacetValue$2(currentRefinement),
+              hierarchicalFacetResult.exhaustive
+            );
+          }),
+          sortBy[0],
+          sortBy[1]
+        );
       }
+
       return hierarchicalTree;
     };
   }
 
   // eslint-disable-next-line max-params
-  function onlyMatchingTree(facetValue, parentPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel) {
+  function onlyMatchingTree(
+    facetValue,
+    parentPath,
+    currentRefinement,
+    hierarchicalSeparator,
+    hierarchicalRootPath,
+    hierarchicalShowParentLevel
+  ) {
     // we want the facetValue is a child of hierarchicalRootPath
-    if (hierarchicalRootPath && (facetValue.indexOf(hierarchicalRootPath) !== 0 || hierarchicalRootPath === facetValue)) {
+    if (
+      hierarchicalRootPath &&
+      (facetValue.indexOf(hierarchicalRootPath) !== 0 ||
+        hierarchicalRootPath === facetValue)
+    ) {
       return false;
     }
 
     // we always want root levels (only when there is no prefix path)
-    return !hierarchicalRootPath && facetValue.indexOf(hierarchicalSeparator) === -1 ||
-    // if there is a rootPath, being root level mean 1 level under rootPath
-    hierarchicalRootPath && facetValue.split(hierarchicalSeparator).length - hierarchicalRootPath.split(hierarchicalSeparator).length === 1 ||
-    // if current refinement is a root level and current facetValue is a root level,
-    // keep the facetValue
-    facetValue.indexOf(hierarchicalSeparator) === -1 && currentRefinement.indexOf(hierarchicalSeparator) === -1 ||
-    // currentRefinement is a child of the facet value
-    currentRefinement.indexOf(facetValue) === 0 ||
-    // facetValue is a child of the current parent, add it
-    facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 && (hierarchicalShowParentLevel || facetValue.indexOf(currentRefinement) === 0);
+    return (
+      (!hierarchicalRootPath &&
+        facetValue.indexOf(hierarchicalSeparator) === -1) ||
+      // if there is a rootPath, being root level mean 1 level under rootPath
+      (hierarchicalRootPath &&
+        facetValue.split(hierarchicalSeparator).length -
+          hierarchicalRootPath.split(hierarchicalSeparator).length ===
+          1) ||
+      // if current refinement is a root level and current facetValue is a root level,
+      // keep the facetValue
+      (facetValue.indexOf(hierarchicalSeparator) === -1 &&
+        currentRefinement.indexOf(hierarchicalSeparator) === -1) ||
+      // currentRefinement is a child of the facet value
+      currentRefinement.indexOf(facetValue) === 0 ||
+      // facetValue is a child of the current parent, add it
+      (facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 &&
+        (hierarchicalShowParentLevel ||
+          facetValue.indexOf(currentRefinement) === 0))
+    );
   }
-  function format(facetCount, facetValue, hierarchicalSeparator, currentRefinement, exhaustive) {
+
+  function format(
+    facetCount,
+    facetValue,
+    hierarchicalSeparator,
+    currentRefinement,
+    exhaustive
+  ) {
     var parts = facetValue.split(hierarchicalSeparator);
     return {
       name: parts[parts.length - 1].trim(),
       path: facetValue,
       escapedValue: escapeFacetValue$2(facetValue),
       count: facetCount,
-      isRefined: currentRefinement === facetValue || currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,
+      isRefined:
+        currentRefinement === facetValue ||
+        currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,
       exhaustive: exhaustive,
-      data: null
+      data: null,
     };
   }
 
@@ -7426,6 +7962,7 @@
   var unescapeFacetValue$3 = escapeFacetValue_1.unescapeFacetValue;
 
 
+
   /**
    * @typedef SearchResults.Facet
    * @type {object}
@@ -7474,11 +8011,14 @@
    */
   function getIndices(attributes) {
     var indices = {};
+
     attributes.forEach(function (val, idx) {
       indices[val] = idx;
     });
+
     return indices;
   }
+
   function assignFacetStats(dest, facetStats, key) {
     if (facetStats && facetStats[key]) {
       dest.stats = facetStats[key];
@@ -7496,11 +8036,17 @@
    * @param {string} hierarchicalAttributeName The name of the hierarchical attribute
    * @return {HierarchicalFacet} The hierarchical facet matching the attribute name
    */
-  function findMatchingHierarchicalFacetFromAttributeName(hierarchicalFacets, hierarchicalAttributeName) {
-    return find$1(hierarchicalFacets, function facetKeyMatchesAttribute(hierarchicalFacet) {
-      var facetNames = hierarchicalFacet.attributes || [];
-      return facetNames.indexOf(hierarchicalAttributeName) > -1;
-    });
+  function findMatchingHierarchicalFacetFromAttributeName(
+    hierarchicalFacets,
+    hierarchicalAttributeName
+  ) {
+    return find$1(
+      hierarchicalFacets,
+      function facetKeyMatchesAttribute(hierarchicalFacet) {
+        var facetNames = hierarchicalFacet.attributes || [];
+        return facetNames.indexOf(hierarchicalAttributeName) > -1;
+      }
+    );
   }
 
   // eslint-disable-next-line valid-jsdoc
@@ -7636,6 +8182,7 @@
    **/
   function SearchResults(state, results, options) {
     var mainSubResponse = results[0];
+
     this._rawResults = results;
 
     // eslint-disable-next-line consistent-this
@@ -7792,7 +8339,9 @@
      * @instance
      */
     this.processingTimeMS = results.reduce(function (sum, result) {
-      return result.processingTimeMS === undefined ? sum : sum + result.processingTimeMS;
+      return result.processingTimeMS === undefined
+        ? sum
+        : sum + result.processingTimeMS;
     }, 0);
 
     /**
@@ -7804,15 +8353,19 @@
      * disjunctive facets results
      * @member {SearchResults.HierarchicalFacet[]}
      */
-    this.hierarchicalFacets = state.hierarchicalFacets.map(function initFutureTree() {
-      return [];
-    });
+    this.hierarchicalFacets = state.hierarchicalFacets.map(
+      function initFutureTree() {
+        return [];
+      }
+    );
     /**
      * other facets results
      * @member {SearchResults.Facet[]}
      */
     this.facets = [];
+
     var disjunctiveFacets = state.getRefinedDisjunctiveFacets();
+
     var facetsIndices = getIndices(state.facets);
     var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);
     var nextDisjunctiveResult = 1;
@@ -7821,9 +8374,15 @@
     // we get the facets information from the first, general, response.
 
     var mainFacets = mainSubResponse.facets || {};
+
     Object.keys(mainFacets).forEach(function (facetKey) {
       var facetValueObject = mainFacets[facetKey];
-      var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(state.hierarchicalFacets, facetKey);
+
+      var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(
+        state.hierarchicalFacets,
+        facetKey
+      );
+
       if (hierarchicalFacet) {
         // Place the hierarchicalFacet data at the correct index depending on
         // the attributes order that was defined at the helper initialization
@@ -7834,29 +8393,38 @@
         self.hierarchicalFacets[idxAttributeName][facetIndex] = {
           attribute: facetKey,
           data: facetValueObject,
-          exhaustive: mainSubResponse.exhaustiveFacetsCount
+          exhaustive: mainSubResponse.exhaustiveFacetsCount,
         };
       } else {
         var isFacetDisjunctive = state.disjunctiveFacets.indexOf(facetKey) !== -1;
         var isFacetConjunctive = state.facets.indexOf(facetKey) !== -1;
         var position;
+
         if (isFacetDisjunctive) {
           position = disjunctiveFacetsIndices[facetKey];
           self.disjunctiveFacets[position] = {
             name: facetKey,
             data: facetValueObject,
-            exhaustive: mainSubResponse.exhaustiveFacetsCount
+            exhaustive: mainSubResponse.exhaustiveFacetsCount,
           };
-          assignFacetStats(self.disjunctiveFacets[position], mainSubResponse.facets_stats, facetKey);
+          assignFacetStats(
+            self.disjunctiveFacets[position],
+            mainSubResponse.facets_stats,
+            facetKey
+          );
         }
         if (isFacetConjunctive) {
           position = facetsIndices[facetKey];
           self.facets[position] = {
             name: facetKey,
             data: facetValueObject,
-            exhaustive: mainSubResponse.exhaustiveFacetsCount
+            exhaustive: mainSubResponse.exhaustiveFacetsCount,
           };
-          assignFacetStats(self.facets[position], mainSubResponse.facets_stats, facetKey);
+          assignFacetStats(
+            self.facets[position],
+            mainSubResponse.facets_stats,
+            facetKey
+          );
         }
       }
     });
@@ -7873,33 +8441,58 @@
       // There should be only item in facets.
       Object.keys(facets).forEach(function (dfacet) {
         var facetResults = facets[dfacet];
+
         var position;
+
         if (hierarchicalFacet) {
           position = findIndex$1(state.hierarchicalFacets, function (f) {
             return f.name === hierarchicalFacet.name;
           });
-          var attributeIndex = findIndex$1(self.hierarchicalFacets[position], function (f) {
-            return f.attribute === dfacet;
-          });
+          var attributeIndex = findIndex$1(
+            self.hierarchicalFacets[position],
+            function (f) {
+              return f.attribute === dfacet;
+            }
+          );
 
           // previous refinements and no results so not able to find it
           if (attributeIndex === -1) {
             return;
           }
-          self.hierarchicalFacets[position][attributeIndex].data = merge$1({}, self.hierarchicalFacets[position][attributeIndex].data, facetResults);
+
+          self.hierarchicalFacets[position][attributeIndex].data = merge_1(
+            {},
+            self.hierarchicalFacets[position][attributeIndex].data,
+            facetResults
+          );
         } else {
           position = disjunctiveFacetsIndices[dfacet];
-          var dataFromMainRequest = mainSubResponse.facets && mainSubResponse.facets[dfacet] || {};
+
+          var dataFromMainRequest =
+            (mainSubResponse.facets && mainSubResponse.facets[dfacet]) || {};
+
           self.disjunctiveFacets[position] = {
             name: dfacet,
             data: defaultsPure({}, facetResults, dataFromMainRequest),
-            exhaustive: result.exhaustiveFacetsCount
+            exhaustive: result.exhaustiveFacetsCount,
           };
-          assignFacetStats(self.disjunctiveFacets[position], result.facets_stats, dfacet);
+          assignFacetStats(
+            self.disjunctiveFacets[position],
+            result.facets_stats,
+            dfacet
+          );
+
           if (state.disjunctiveFacetsRefinements[dfacet]) {
-            state.disjunctiveFacetsRefinements[dfacet].forEach(function (refinementValue) {
+            state.disjunctiveFacetsRefinements[dfacet].forEach(function (
+              refinementValue
+            ) {
               // add the disjunctive refinements if it is no more retrieved
-              if (!self.disjunctiveFacets[position].data[refinementValue] && state.disjunctiveFacetsRefinements[dfacet].indexOf(unescapeFacetValue$3(refinementValue)) > -1) {
+              if (
+                !self.disjunctiveFacets[position].data[refinementValue] &&
+                state.disjunctiveFacetsRefinements[dfacet].indexOf(
+                  unescapeFacetValue$3(refinementValue)
+                ) > -1
+              ) {
                 self.disjunctiveFacets[position].data[refinementValue] = 0;
               }
             });
@@ -7913,22 +8506,31 @@
     state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {
       var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);
       var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
+
       var currentRefinement = state.getHierarchicalRefinement(refinedFacet);
       // if we are already at a root refinement (or no refinement at all), there is no
       // root level values request
-      if (currentRefinement.length === 0 || currentRefinement[0].split(separator).length < 2) {
+      if (
+        currentRefinement.length === 0 ||
+        currentRefinement[0].split(separator).length < 2
+      ) {
         return;
       }
+
       results.slice(nextDisjunctiveResult).forEach(function (result) {
         var facets = result && result.facets ? result.facets : {};
+
         Object.keys(facets).forEach(function (dfacet) {
           var facetResults = facets[dfacet];
           var position = findIndex$1(state.hierarchicalFacets, function (f) {
             return f.name === hierarchicalFacet.name;
           });
-          var attributeIndex = findIndex$1(self.hierarchicalFacets[position], function (f) {
-            return f.attribute === dfacet;
-          });
+          var attributeIndex = findIndex$1(
+            self.hierarchicalFacets[position],
+            function (f) {
+              return f.attribute === dfacet;
+            }
+          );
 
           // previous refinements and no results so not able to find it
           if (attributeIndex === -1) {
@@ -7944,12 +8546,20 @@
           //   | beers (5)
           //     > IPA (5)
           var defaultData = {};
+
           if (currentRefinement.length > 0) {
             var root = currentRefinement[0].split(separator)[0];
-            defaultData[root] = self.hierarchicalFacets[position][attributeIndex].data[root];
+            defaultData[root] =
+              self.hierarchicalFacets[position][attributeIndex].data[root];
           }
-          self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(defaultData, facetResults, self.hierarchicalFacets[position][attributeIndex].data);
+
+          self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(
+            defaultData,
+            facetResults,
+            self.hierarchicalFacets[position][attributeIndex].data
+          );
         });
+
         nextDisjunctiveResult++;
       });
     });
@@ -7958,15 +8568,14 @@
     Object.keys(state.facetsExcludes).forEach(function (facetName) {
       var excludes = state.facetsExcludes[facetName];
       var position = facetsIndices[facetName];
+
       self.facets[position] = {
         name: facetName,
         data: mainFacets[facetName],
-        exhaustive: mainSubResponse.exhaustiveFacetsCount
+        exhaustive: mainSubResponse.exhaustiveFacetsCount,
       };
       excludes.forEach(function (facetValue) {
-        self.facets[position] = self.facets[position] || {
-          name: facetName
-        };
+        self.facets[position] = self.facets[position] || { name: facetName };
         self.facets[position].data = self.facets[position].data || {};
         self.facets[position].data[facetValue] = 0;
       });
@@ -7975,7 +8584,9 @@
     /**
      * @type {Array}
      */
-    this.hierarchicalFacets = this.hierarchicalFacets.map(generateHierarchicalTree_1(state));
+    this.hierarchicalFacets = this.hierarchicalFacets.map(
+      generateHierarchicalTree_1(state)
+    );
 
     /**
      * @type {Array}
@@ -7985,6 +8596,7 @@
      * @type {Array}
      */
     this.disjunctiveFacets = compact(this.disjunctiveFacets);
+
     this._state = state;
   }
 
@@ -7998,7 +8610,12 @@
     function predicate(facet) {
       return facet.name === name;
     }
-    return find$1(this.facets, predicate) || find$1(this.disjunctiveFacets, predicate) || find$1(this.hierarchicalFacets, predicate);
+
+    return (
+      find$1(this.facets, predicate) ||
+      find$1(this.disjunctiveFacets, predicate) ||
+      find$1(this.hierarchicalFacets, predicate)
+    );
   };
 
   /**
@@ -8012,9 +8629,11 @@
     function predicate(facet) {
       return facet.name === attribute;
     }
+
     if (results._state.isConjunctiveFacet(attribute)) {
       var facet = find$1(results.facets, predicate);
       if (!facet) return [];
+
       return Object.keys(facet.data).map(function (name) {
         var value = escapeFacetValue$3(name);
         return {
@@ -8022,35 +8641,49 @@
           escapedValue: value,
           count: facet.data[name],
           isRefined: results._state.isFacetRefined(attribute, value),
-          isExcluded: results._state.isExcludeRefined(attribute, name)
+          isExcluded: results._state.isExcludeRefined(attribute, name),
         };
       });
     } else if (results._state.isDisjunctiveFacet(attribute)) {
       var disjunctiveFacet = find$1(results.disjunctiveFacets, predicate);
       if (!disjunctiveFacet) return [];
+
       return Object.keys(disjunctiveFacet.data).map(function (name) {
         var value = escapeFacetValue$3(name);
         return {
           name: name,
           escapedValue: value,
           count: disjunctiveFacet.data[name],
-          isRefined: results._state.isDisjunctiveFacetRefined(attribute, value)
+          isRefined: results._state.isDisjunctiveFacetRefined(attribute, value),
         };
       });
     } else if (results._state.isHierarchicalFacet(attribute)) {
       var hierarchicalFacetValues = find$1(results.hierarchicalFacets, predicate);
       if (!hierarchicalFacetValues) return hierarchicalFacetValues;
-      var hierarchicalFacet = results._state.getHierarchicalFacetByName(attribute);
-      var separator = results._state._getHierarchicalFacetSeparator(hierarchicalFacet);
-      var currentRefinement = unescapeFacetValue$3(results._state.getHierarchicalRefinement(attribute)[0] || '');
+
+      var hierarchicalFacet =
+        results._state.getHierarchicalFacetByName(attribute);
+      var separator =
+        results._state._getHierarchicalFacetSeparator(hierarchicalFacet);
+      var currentRefinement = unescapeFacetValue$3(
+        results._state.getHierarchicalRefinement(attribute)[0] || ''
+      );
+
       if (currentRefinement.indexOf(hierarchicalFacet.rootPath) === 0) {
-        currentRefinement = currentRefinement.replace(hierarchicalFacet.rootPath + separator, '');
+        currentRefinement = currentRefinement.replace(
+          hierarchicalFacet.rootPath + separator,
+          ''
+        );
       }
+
       var currentRefinementSplit = currentRefinement.split(separator);
       currentRefinementSplit.unshift(attribute);
+
       setIsRefined(hierarchicalFacetValues, currentRefinementSplit, 0);
+
       return hierarchicalFacetValues;
     }
+
     return undefined;
   }
 
@@ -8081,22 +8714,25 @@
    */
   function recSort(sortFn, node, names, level) {
     level = level || 0;
+
     if (Array.isArray(node)) {
       return sortFn(node, names[level]);
     }
+
     if (!node.data || node.data.length === 0) {
       return node;
     }
+
     var children = node.data.map(function (childNode) {
       return recSort(sortFn, childNode, names, level + 1);
     });
     var sortedChildren = sortFn(children, names[level]);
-    var newNode = defaultsPure({
-      data: sortedChildren
-    }, node);
+    var newNode = defaultsPure({ data: sortedChildren }, node);
     return newNode;
   }
+
   SearchResults.DEFAULT_SORT = ['isRefined:desc', 'count:desc', 'name:asc'];
+
   function vanillaSortFn(order, data) {
     return data.sort(order);
   }
@@ -8117,6 +8753,7 @@
   function sortViaFacetOrdering(facetValues, facetOrdering) {
     var orderedFacets = [];
     var remainingFacets = [];
+
     var order = facetOrdering.order || [];
     /**
      * an object with the keys being the values in order, the values their index:
@@ -8126,6 +8763,7 @@
       acc[name] = i;
       return acc;
     }, {});
+
     facetValues.forEach(function (item) {
       // hierarchical facets get sorted using their raw name
       var name = item.path || item.name;
@@ -8135,19 +8773,27 @@
         remainingFacets.push(item);
       }
     });
+
     orderedFacets = orderedFacets.filter(function (facet) {
       return facet;
     });
+
     var sortRemainingBy = facetOrdering.sortRemainingBy;
     var ordering;
     if (sortRemainingBy === 'hidden') {
       return orderedFacets;
     } else if (sortRemainingBy === 'alpha') {
-      ordering = [['path', 'name'], ['asc', 'asc']];
+      ordering = [
+        ['path', 'name'],
+        ['asc', 'asc'],
+      ];
     } else {
       ordering = [['count'], ['desc']];
     }
-    return orderedFacets.concat(orderBy_1(remainingFacets, ordering[0], ordering[1]));
+
+    return orderedFacets.concat(
+      orderBy_1(remainingFacets, ordering[0], ordering[1])
+    );
   }
 
   /**
@@ -8156,7 +8802,12 @@
    * @returns {FacetOrdering | undefined} the facet ordering
    */
   function getFacetOrdering(results, attribute) {
-    return results.renderingContent && results.renderingContent.facetOrdering && results.renderingContent.facetOrdering.values && results.renderingContent.facetOrdering.values[attribute];
+    return (
+      results.renderingContent &&
+      results.renderingContent.facetOrdering &&
+      results.renderingContent.facetOrdering.values &&
+      results.renderingContent.facetOrdering.values[attribute]
+    );
   }
 
   /**
@@ -8212,11 +8863,12 @@
     if (!facetValues) {
       return undefined;
     }
+
     var options = defaultsPure({}, opts, {
       sortBy: SearchResults.DEFAULT_SORT,
       // if no sortBy is given, attempt to sort based on facetOrdering
       // if it is given, we still allow to sort via facet ordering first
-      facetOrdering: !(opts && opts.sortBy)
+      facetOrdering: !(opts && opts.sortBy),
     });
 
     // eslint-disable-next-line consistent-this
@@ -8228,21 +8880,30 @@
       var config = results._state.getHierarchicalFacetByName(facetValues.name);
       attributes = config.attributes;
     }
-    return recSort(function (data, facetName) {
-      if (options.facetOrdering) {
-        var facetOrdering = getFacetOrdering(results, facetName);
-        if (facetOrdering) {
-          return sortViaFacetOrdering(data, facetOrdering);
+
+    return recSort(
+      function (data, facetName) {
+        if (options.facetOrdering) {
+          var facetOrdering = getFacetOrdering(results, facetName);
+          if (facetOrdering) {
+            return sortViaFacetOrdering(data, facetOrdering);
+          }
+        }
+
+        if (Array.isArray(options.sortBy)) {
+          var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);
+          return orderBy_1(data, order[0], order[1]);
+        } else if (typeof options.sortBy === 'function') {
+          return vanillaSortFn(options.sortBy, data);
         }
-      }
-      if (Array.isArray(options.sortBy)) {
-        var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);
-        return orderBy_1(data, order[0], order[1]);
-      } else if (typeof options.sortBy === 'function') {
-        return vanillaSortFn(options.sortBy, data);
-      }
-      throw new Error('options.sortBy is optional but if defined it must be ' + 'either an array of string (predicates) or a sorting function');
-    }, facetValues, attributes);
+        throw new Error(
+          'options.sortBy is optional but if defined it must be ' +
+            'either an array of string (predicates) or a sorting function'
+        );
+      },
+      facetValues,
+      attributes
+    );
   };
 
   /**
@@ -8257,6 +8918,7 @@
     } else if (this._state.isDisjunctiveFacet(attribute)) {
       return getFacetStatsIfAvailable(this.disjunctiveFacets, attribute);
     }
+
     return undefined;
   };
 
@@ -8294,26 +8956,54 @@
     // eslint-disable-next-line consistent-this
     var results = this;
     var res = [];
+
     Object.keys(state.facetsRefinements).forEach(function (attributeName) {
       state.facetsRefinements[attributeName].forEach(function (name) {
-        res.push(getRefinement$1(state, 'facet', attributeName, name, results.facets));
+        res.push(
+          getRefinement$1(state, 'facet', attributeName, name, results.facets)
+        );
       });
     });
+
     Object.keys(state.facetsExcludes).forEach(function (attributeName) {
       state.facetsExcludes[attributeName].forEach(function (name) {
-        res.push(getRefinement$1(state, 'exclude', attributeName, name, results.facets));
+        res.push(
+          getRefinement$1(state, 'exclude', attributeName, name, results.facets)
+        );
       });
     });
-    Object.keys(state.disjunctiveFacetsRefinements).forEach(function (attributeName) {
+
+    Object.keys(state.disjunctiveFacetsRefinements).forEach(function (
+      attributeName
+    ) {
       state.disjunctiveFacetsRefinements[attributeName].forEach(function (name) {
-        res.push(getRefinement$1(state, 'disjunctive', attributeName, name, results.disjunctiveFacets));
+        res.push(
+          getRefinement$1(
+            state,
+            'disjunctive',
+            attributeName,
+            name,
+            results.disjunctiveFacets
+          )
+        );
       });
     });
-    Object.keys(state.hierarchicalFacetsRefinements).forEach(function (attributeName) {
+
+    Object.keys(state.hierarchicalFacetsRefinements).forEach(function (
+      attributeName
+    ) {
       state.hierarchicalFacetsRefinements[attributeName].forEach(function (name) {
-        res.push(getHierarchicalRefinement(state, attributeName, name, results.hierarchicalFacets));
+        res.push(
+          getHierarchicalRefinement(
+            state,
+            attributeName,
+            name,
+            results.hierarchicalFacets
+          )
+        );
       });
     });
+
     Object.keys(state.numericRefinements).forEach(function (attributeName) {
       var operators = state.numericRefinements[attributeName];
       Object.keys(operators).forEach(function (operator) {
@@ -8323,18 +9013,16 @@
             attributeName: attributeName,
             name: value,
             numericValue: value,
-            operator: operator
+            operator: operator,
           });
         });
       });
     });
+
     state.tagRefinements.forEach(function (name) {
-      res.push({
-        type: 'tag',
-        attributeName: '_tags',
-        name: name
-      });
+      res.push({ type: 'tag', attributeName: '_tags', name: name });
     });
+
     return res;
   };
 
@@ -8358,13 +9046,14 @@
       return f.name === attributeName;
     });
     var count = facet && facet.data && facet.data[name] ? facet.data[name] : 0;
-    var exhaustive = facet && facet.exhaustive || false;
+    var exhaustive = (facet && facet.exhaustive) || false;
+
     return {
       type: type,
       attributeName: attributeName,
       name: name,
       count: count,
-      exhaustive: exhaustive
+      exhaustive: exhaustive,
     };
   }
 
@@ -8382,23 +9071,29 @@
     var rootFacet = find$1(resultsFacets, function (facet) {
       return facet.name === attributeName;
     });
+
     var facet = split.reduce(function (intermediateFacet, part) {
-      var newFacet = intermediateFacet && find$1(intermediateFacet.data, function (f) {
-        return f.name === part;
-      });
+      var newFacet =
+        intermediateFacet &&
+        find$1(intermediateFacet.data, function (f) {
+          return f.name === part;
+        });
       return newFacet !== undefined ? newFacet : intermediateFacet;
     }, rootFacet);
-    var count = facet && facet.count || 0;
-    var exhaustive = facet && facet.exhaustive || false;
-    var path = facet && facet.path || '';
+
+    var count = (facet && facet.count) || 0;
+    var exhaustive = (facet && facet.exhaustive) || false;
+    var path = (facet && facet.path) || '';
+
     return {
       type: 'hierarchical',
       attributeName: attributeName,
       name: path,
       count: count,
-      exhaustive: exhaustive
+      exhaustive: exhaustive,
     };
   }
+
   var SearchResults_1 = SearchResults;
 
   // Copyright Joyent, Inc. and other Node contributors.
@@ -8710,10 +9405,11 @@
         value: ctor,
         enumerable: false,
         writable: true,
-        configurable: true
-      }
+        configurable: true,
+      },
     });
   }
+
   var inherits_1 = inherits;
 
   /**
@@ -8733,6 +9429,7 @@
     this.fn = fn;
     this.lastResults = null;
   }
+
   inherits_1(DerivedHelper, events);
 
   /**
@@ -8744,19 +9441,24 @@
     this.removeAllListeners();
     this.main.detachDerivedHelper(this);
   };
+
   DerivedHelper.prototype.getModifiedState = function (parameters) {
     return this.fn(parameters);
   };
+
   var DerivedHelper_1 = DerivedHelper;
 
   function sortObject(obj) {
-    return Object.keys(obj).sort(function (a, b) {
-      return a.localeCompare(b);
-    }).reduce(function (acc, curr) {
-      acc[curr] = obj[curr];
-      return acc;
-    }, {});
+    return Object.keys(obj)
+      .sort(function (a, b) {
+        return a.localeCompare(b);
+      })
+      .reduce(function (acc, curr) {
+        acc[curr] = obj[curr];
+        return acc;
+      }, {});
   }
+
   var requestBuilder = {
     /**
      * Get all the queries to send to the client, those queries can used directly
@@ -8772,14 +9474,17 @@
       // One query for the hits
       queries.push({
         indexName: index,
-        params: requestBuilder._getHitsSearchParams(state)
+        params: requestBuilder._getHitsSearchParams(state),
       });
 
       // One for each disjunctive facets
       state.getRefinedDisjunctiveFacets().forEach(function (refinedFacet) {
         queries.push({
           indexName: index,
-          params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet)
+          params: requestBuilder._getDisjunctiveFacetSearchParams(
+            state,
+            refinedFacet
+          ),
         });
       });
 
@@ -8791,16 +9496,30 @@
 
         // If we are deeper than level 0 (starting from `beer > IPA`)
         // we want to get all parent values
-        if (currentRefinement.length > 0 && currentRefinement[0].split(separator).length > 1) {
+        if (
+          currentRefinement.length > 0 &&
+          currentRefinement[0].split(separator).length > 1
+        ) {
           // We generate a map of the filters we will use for our facet values queries
-          var filtersMap = currentRefinement[0].split(separator).slice(0, -1).reduce(function createFiltersMap(map, segment, level) {
-            return map.concat({
-              attribute: hierarchicalFacet.attributes[level],
-              value: level === 0 ? segment : [map[map.length - 1].value, segment].join(separator)
-            });
-          }, []);
+          var filtersMap = currentRefinement[0]
+            .split(separator)
+            .slice(0, -1)
+            .reduce(function createFiltersMap(map, segment, level) {
+              return map.concat({
+                attribute: hierarchicalFacet.attributes[level],
+                value:
+                  level === 0
+                    ? segment
+                    : [map[map.length - 1].value, segment].join(separator),
+              });
+            }, []);
+
           filtersMap.forEach(function (filter, level) {
-            var params = requestBuilder._getDisjunctiveFacetSearchParams(state, filter.attribute, level === 0);
+            var params = requestBuilder._getDisjunctiveFacetSearchParams(
+              state,
+              filter.attribute,
+              level === 0
+            );
 
             // Keep facet filters unrelated to current hierarchical attributes
             function hasHierarchicalFacetFilter(value) {
@@ -8808,58 +9527,81 @@
                 return attribute === value.split(':')[0];
               });
             }
-            var filteredFacetFilters = (params.facetFilters || []).reduce(function (acc, facetFilter) {
-              if (Array.isArray(facetFilter)) {
-                var filtered = facetFilter.filter(function (filterValue) {
-                  return !hasHierarchicalFacetFilter(filterValue);
-                });
-                if (filtered.length > 0) {
-                  acc.push(filtered);
+
+            var filteredFacetFilters = (params.facetFilters || []).reduce(
+              function (acc, facetFilter) {
+                if (Array.isArray(facetFilter)) {
+                  var filtered = facetFilter.filter(function (filterValue) {
+                    return !hasHierarchicalFacetFilter(filterValue);
+                  });
+
+                  if (filtered.length > 0) {
+                    acc.push(filtered);
+                  }
                 }
-              }
-              if (typeof facetFilter === 'string' && !hasHierarchicalFacetFilter(facetFilter)) {
-                acc.push(facetFilter);
-              }
-              return acc;
-            }, []);
+
+                if (
+                  typeof facetFilter === 'string' &&
+                  !hasHierarchicalFacetFilter(facetFilter)
+                ) {
+                  acc.push(facetFilter);
+                }
+
+                return acc;
+              },
+              []
+            );
+
             var parent = filtersMap[level - 1];
             if (level > 0) {
-              params.facetFilters = filteredFacetFilters.concat(parent.attribute + ':' + parent.value);
+              params.facetFilters = filteredFacetFilters.concat(
+                parent.attribute + ':' + parent.value
+              );
             } else {
-              params.facetFilters = filteredFacetFilters.length > 0 ? filteredFacetFilters : undefined;
+              params.facetFilters =
+                filteredFacetFilters.length > 0
+                  ? filteredFacetFilters
+                  : undefined;
             }
-            queries.push({
-              indexName: index,
-              params: params
-            });
+
+            queries.push({ indexName: index, params: params });
           });
         }
       });
+
       return queries;
     },
+
     /**
      * Build search parameters used to fetch hits
      * @private
      * @param  {SearchParameters} state The state from which to get the queries
      * @return {object.<string, any>} The search parameters for hits
      */
-    _getHitsSearchParams: function _getHitsSearchParams(state) {
-      var facets = state.facets.concat(state.disjunctiveFacets).concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state));
+    _getHitsSearchParams: function (state) {
+      var facets = state.facets
+        .concat(state.disjunctiveFacets)
+        .concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state));
+
       var facetFilters = requestBuilder._getFacetFilters(state);
       var numericFilters = requestBuilder._getNumericFilters(state);
       var tagFilters = requestBuilder._getTagFilters(state);
       var additionalParams = {
         facets: facets.indexOf('*') > -1 ? ['*'] : facets,
-        tagFilters: tagFilters
+        tagFilters: tagFilters,
       };
+
       if (facetFilters.length > 0) {
         additionalParams.facetFilters = facetFilters;
       }
+
       if (numericFilters.length > 0) {
         additionalParams.numericFilters = numericFilters;
       }
-      return sortObject(merge$1({}, state.getQueryParams(), additionalParams));
+
+      return sortObject(merge_1({}, state.getQueryParams(), additionalParams));
     },
+
     /**
      * Build search parameters used to fetch a disjunctive facet
      * @private
@@ -8868,33 +9610,53 @@
      * @param  {boolean} hierarchicalRootLevel ?? FIXME
      * @return {object} The search parameters for a disjunctive facet
      */
-    _getDisjunctiveFacetSearchParams: function _getDisjunctiveFacetSearchParams(state, facet, hierarchicalRootLevel) {
-      var facetFilters = requestBuilder._getFacetFilters(state, facet, hierarchicalRootLevel);
+    _getDisjunctiveFacetSearchParams: function (
+      state,
+      facet,
+      hierarchicalRootLevel
+    ) {
+      var facetFilters = requestBuilder._getFacetFilters(
+        state,
+        facet,
+        hierarchicalRootLevel
+      );
       var numericFilters = requestBuilder._getNumericFilters(state, facet);
       var tagFilters = requestBuilder._getTagFilters(state);
       var additionalParams = {
         hitsPerPage: 0,
         page: 0,
         analytics: false,
-        clickAnalytics: false
+        clickAnalytics: false,
       };
+
       if (tagFilters.length > 0) {
         additionalParams.tagFilters = tagFilters;
       }
+
       var hierarchicalFacet = state.getHierarchicalFacetByName(facet);
+
       if (hierarchicalFacet) {
-        additionalParams.facets = requestBuilder._getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, hierarchicalRootLevel);
+        additionalParams.facets =
+          requestBuilder._getDisjunctiveHierarchicalFacetAttribute(
+            state,
+            hierarchicalFacet,
+            hierarchicalRootLevel
+          );
       } else {
         additionalParams.facets = facet;
       }
+
       if (numericFilters.length > 0) {
         additionalParams.numericFilters = numericFilters;
       }
+
       if (facetFilters.length > 0) {
         additionalParams.facetFilters = facetFilters;
       }
-      return sortObject(merge$1({}, state.getQueryParams(), additionalParams));
+
+      return sortObject(merge_1({}, state.getQueryParams(), additionalParams));
     },
+
     /**
      * Return the numeric filters in an algolia request fashion
      * @private
@@ -8902,11 +9664,13 @@
      * @param {string} [facetName] the name of the attribute for which the filters should be excluded
      * @return {string[]} the numeric filters in the algolia format
      */
-    _getNumericFilters: function _getNumericFilters(state, facetName) {
+    _getNumericFilters: function (state, facetName) {
       if (state.numericFilters) {
         return state.numericFilters;
       }
+
       var numericFilters = [];
+
       Object.keys(state.numericRefinements).forEach(function (attribute) {
         var operators = state.numericRefinements[attribute] || {};
         Object.keys(operators).forEach(function (operator) {
@@ -8925,20 +9689,24 @@
           }
         });
       });
+
       return numericFilters;
     },
+
     /**
      * Return the tags filters depending on which format is used, either tagFilters or tagRefinements
      * @private
      * @param {SearchParameters} state the state from which to get the filters
      * @return {string} Tag filters in a single string
      */
-    _getTagFilters: function _getTagFilters(state) {
+    _getTagFilters: function (state) {
       if (state.tagFilters) {
         return state.tagFilters;
       }
+
       return state.tagRefinements.join(',');
     },
+
     /**
      * Build facetFilters parameter based on current refinements. The array returned
      * contains strings representing the facet filters in the algolia format.
@@ -8948,8 +9716,9 @@
      * @param  {boolean} [hierarchicalRootLevel] ?? FIXME
      * @return {array.<string>} The facet filters in the algolia format
      */
-    _getFacetFilters: function _getFacetFilters(state, facet, hierarchicalRootLevel) {
+    _getFacetFilters: function (state, facet, hierarchicalRootLevel) {
       var facetFilters = [];
+
       var facetsRefinements = state.facetsRefinements || {};
       Object.keys(facetsRefinements).forEach(function (facetName) {
         var facetValues = facetsRefinements[facetName] || [];
@@ -8957,6 +9726,7 @@
           facetFilters.push(facetName + ':' + facetValue);
         });
       });
+
       var facetsExcludes = state.facetsExcludes || {};
       Object.keys(facetsExcludes).forEach(function (facetName) {
         var facetValues = facetsExcludes[facetName] || [];
@@ -8964,6 +9734,7 @@
           facetFilters.push(facetName + ':-' + facetValue);
         });
       });
+
       var disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements || {};
       Object.keys(disjunctiveFacetsRefinements).forEach(function (facetName) {
         var facetValues = disjunctiveFacetsRefinements[facetName] || [];
@@ -8971,18 +9742,24 @@
           return;
         }
         var orFilters = [];
+
         facetValues.forEach(function (facetValue) {
           orFilters.push(facetName + ':' + facetValue);
         });
+
         facetFilters.push(orFilters);
       });
-      var hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements || {};
+
+      var hierarchicalFacetsRefinements =
+        state.hierarchicalFacetsRefinements || {};
       Object.keys(hierarchicalFacetsRefinements).forEach(function (facetName) {
         var facetValues = hierarchicalFacetsRefinements[facetName] || [];
         var facetValue = facetValues[0];
+
         if (facetValue === undefined) {
           return;
         }
+
         var hierarchicalFacet = state.getHierarchicalFacetByName(facetName);
         var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
         var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);
@@ -8993,9 +9770,16 @@
         if (facet === facetName) {
           // if we are at the root level already, no need to ask for facet values, we get them from
           // the hits query
-          if (facetValue.indexOf(separator) === -1 || !rootPath && hierarchicalRootLevel === true || rootPath && rootPath.split(separator).length === facetValue.split(separator).length) {
+          if (
+            facetValue.indexOf(separator) === -1 ||
+            (!rootPath && hierarchicalRootLevel === true) ||
+            (rootPath &&
+              rootPath.split(separator).length ===
+                facetValue.split(separator).length)
+          ) {
             return;
           }
+
           if (!rootPath) {
             attributesIndex = facetValue.split(separator).length - 2;
             facetValue = facetValue.slice(0, facetValue.lastIndexOf(separator));
@@ -9003,67 +9787,100 @@
             attributesIndex = rootPath.split(separator).length - 1;
             facetValue = rootPath;
           }
+
           attributeToRefine = hierarchicalFacet.attributes[attributesIndex];
         } else {
           attributesIndex = facetValue.split(separator).length - 1;
+
           attributeToRefine = hierarchicalFacet.attributes[attributesIndex];
         }
+
         if (attributeToRefine) {
           facetFilters.push([attributeToRefine + ':' + facetValue]);
         }
       });
+
       return facetFilters;
     },
-    _getHitsHierarchicalFacetsAttributes: function _getHitsHierarchicalFacetsAttributes(state) {
+
+    _getHitsHierarchicalFacetsAttributes: function (state) {
       var out = [];
+
       return state.hierarchicalFacets.reduce(
-      // ask for as much levels as there's hierarchical refinements
-      function getHitsAttributesForHierarchicalFacet(allAttributes, hierarchicalFacet) {
-        var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0];
-
-        // if no refinement, ask for root level
-        if (!hierarchicalRefinement) {
-          allAttributes.push(hierarchicalFacet.attributes[0]);
-          return allAttributes;
-        }
-        var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
-        var level = hierarchicalRefinement.split(separator).length;
-        var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);
-        return allAttributes.concat(newAttributes);
-      }, out);
+        // ask for as much levels as there's hierarchical refinements
+        function getHitsAttributesForHierarchicalFacet(
+          allAttributes,
+          hierarchicalFacet
+        ) {
+          var hierarchicalRefinement = state.getHierarchicalRefinement(
+            hierarchicalFacet.name
+          )[0];
+
+          // if no refinement, ask for root level
+          if (!hierarchicalRefinement) {
+            allAttributes.push(hierarchicalFacet.attributes[0]);
+            return allAttributes;
+          }
+
+          var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
+          var level = hierarchicalRefinement.split(separator).length;
+          var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);
+
+          return allAttributes.concat(newAttributes);
+        },
+        out
+      );
     },
-    _getDisjunctiveHierarchicalFacetAttribute: function _getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, rootLevel) {
+
+    _getDisjunctiveHierarchicalFacetAttribute: function (
+      state,
+      hierarchicalFacet,
+      rootLevel
+    ) {
       var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
       if (rootLevel === true) {
         var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);
         var attributeIndex = 0;
+
         if (rootPath) {
           attributeIndex = rootPath.split(separator).length;
         }
         return [hierarchicalFacet.attributes[attributeIndex]];
       }
-      var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || '';
+
+      var hierarchicalRefinement =
+        state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || '';
       // if refinement is 'beers > IPA > Flying dog',
       // then we want `facets: ['beers > IPA']` as disjunctive facet (parent level values)
 
       var parentLevel = hierarchicalRefinement.split(separator).length - 1;
       return hierarchicalFacet.attributes.slice(0, parentLevel + 1);
     },
-    getSearchForFacetQuery: function getSearchForFacetQuery(facetName, query, maxFacetHits, state) {
-      var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ? state.clearRefinements(facetName) : state;
+
+    getSearchForFacetQuery: function (facetName, query, maxFacetHits, state) {
+      var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName)
+        ? state.clearRefinements(facetName)
+        : state;
       var searchForFacetSearchParameters = {
         facetQuery: query,
-        facetName: facetName
+        facetName: facetName,
       };
       if (typeof maxFacetHits === 'number') {
         searchForFacetSearchParameters.maxFacetHits = maxFacetHits;
       }
-      return sortObject(merge$1({}, requestBuilder._getHitsSearchParams(stateForSearchForFacetValues), searchForFacetSearchParameters));
-    }
+      return sortObject(
+        merge_1(
+          {},
+          requestBuilder._getHitsSearchParams(stateForSearchForFacetValues),
+          searchForFacetSearchParameters
+        )
+      );
+    },
   };
+
   var requestBuilder_1 = requestBuilder;
 
-  var version = '3.13.3';
+  var version = '3.13.5';
 
   var escapeFacetValue$4 = escapeFacetValue_1.escapeFacetValue;
 
@@ -9174,6 +9991,7 @@
     if (typeof client.addAlgoliaAgent === 'function') {
       client.addAlgoliaAgent('JS Helper (' + version + ')');
     }
+
     this.setClient(client);
     var opts = options || {};
     opts.index = index;
@@ -9184,6 +10002,7 @@
     this.derivedHelpers = [];
     this._currentNbQueries = 0;
   }
+
   inherits_1(AlgoliaSearchHelper, events);
 
   /**
@@ -9198,15 +10017,12 @@
    * @chainable
    */
   AlgoliaSearchHelper.prototype.search = function () {
-    this._search({
-      onlyWithDerivedHelpers: false
-    });
+    this._search({ onlyWithDerivedHelpers: false });
     return this;
   };
+
   AlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function () {
-    this._search({
-      onlyWithDerivedHelpers: true
-    });
+    this._search({ onlyWithDerivedHelpers: true });
     return this;
   };
 
@@ -9257,43 +10073,58 @@
    * }
    */
   AlgoliaSearchHelper.prototype.searchOnce = function (options, cb) {
-    var tempState = !options ? this.state : this.state.setQueryParameters(options);
+    var tempState = !options
+      ? this.state
+      : this.state.setQueryParameters(options);
     var queries = requestBuilder_1._getQueries(tempState.index, tempState);
     // eslint-disable-next-line consistent-this
     var self = this;
+
     this._currentNbQueries++;
+
     this.emit('searchOnce', {
-      state: tempState
+      state: tempState,
     });
+
     if (cb) {
-      this.client.search(queries).then(function (content) {
-        self._currentNbQueries--;
-        if (self._currentNbQueries === 0) {
-          self.emit('searchQueueEmpty');
-        }
-        cb(null, new SearchResults_1(tempState, content.results), tempState);
-      }).catch(function (err) {
-        self._currentNbQueries--;
-        if (self._currentNbQueries === 0) {
-          self.emit('searchQueueEmpty');
-        }
-        cb(err, null, tempState);
-      });
+      this.client
+        .search(queries)
+        .then(function (content) {
+          self._currentNbQueries--;
+          if (self._currentNbQueries === 0) {
+            self.emit('searchQueueEmpty');
+          }
+
+          cb(null, new SearchResults_1(tempState, content.results), tempState);
+        })
+        .catch(function (err) {
+          self._currentNbQueries--;
+          if (self._currentNbQueries === 0) {
+            self.emit('searchQueueEmpty');
+          }
+
+          cb(err, null, tempState);
+        });
+
       return undefined;
     }
-    return this.client.search(queries).then(function (content) {
-      self._currentNbQueries--;
-      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
-      return {
-        content: new SearchResults_1(tempState, content.results),
-        state: tempState,
-        _originalResponse: content
-      };
-    }, function (e) {
-      self._currentNbQueries--;
-      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
-      throw e;
-    });
+
+    return this.client.search(queries).then(
+      function (content) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
+        return {
+          content: new SearchResults_1(tempState, content.results),
+          state: tempState,
+          _originalResponse: content,
+        };
+      },
+      function (e) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
+        throw e;
+      }
+    );
   };
 
   /**
@@ -9316,13 +10147,23 @@
       return Promise.resolve([]);
     }
     var derivedState = derivedHelper.getModifiedState(state);
-    var data = merge$1({
-      attributesForPrediction: options.attributesForPrediction,
-      nbHits: options.nbHits
-    }, {
-      params: omit$1(requestBuilder_1._getHitsSearchParams(derivedState), ['attributesToSnippet', 'hitsPerPage', 'restrictSearchableAttributes', 'snippetEllipsisText'])
-    });
-    var errorMessage = 'search for answers was called, but this client does not have a function client.initIndex(index).findAnswers';
+    var data = merge_1(
+      {
+        attributesForPrediction: options.attributesForPrediction,
+        nbHits: options.nbHits,
+      },
+      {
+        params: omit$1(requestBuilder_1._getHitsSearchParams(derivedState), [
+          'attributesToSnippet',
+          'hitsPerPage',
+          'restrictSearchableAttributes',
+          'snippetEllipsisText',
+        ]),
+      }
+    );
+
+    var errorMessage =
+      'search for answers was called, but this client does not have a function client.initIndex(index).findAnswers';
     if (typeof this.client.initIndex !== 'function') {
       throw new Error(errorMessage);
     }
@@ -9367,60 +10208,93 @@
    * it in the generated query.
    * @return {promise.<FacetSearchResult>} the results of the search
    */
-  AlgoliaSearchHelper.prototype.searchForFacetValues = function (facet, query, maxFacetHits, userState) {
+  AlgoliaSearchHelper.prototype.searchForFacetValues = function (
+    facet,
+    query,
+    maxFacetHits,
+    userState
+  ) {
     var clientHasSFFV = typeof this.client.searchForFacetValues === 'function';
     var clientHasInitIndex = typeof this.client.initIndex === 'function';
-    if (!clientHasSFFV && !clientHasInitIndex && typeof this.client.search !== 'function') {
-      throw new Error('search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues or client.initIndex(index).searchForFacetValues');
+    if (
+      !clientHasSFFV &&
+      !clientHasInitIndex &&
+      typeof this.client.search !== 'function'
+    ) {
+      throw new Error(
+        'search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues or client.initIndex(index).searchForFacetValues'
+      );
     }
+
     var state = this.state.setQueryParameters(userState || {});
     var isDisjunctive = state.isDisjunctiveFacet(facet);
-    var algoliaQuery = requestBuilder_1.getSearchForFacetQuery(facet, query, maxFacetHits, state);
+    var algoliaQuery = requestBuilder_1.getSearchForFacetQuery(
+      facet,
+      query,
+      maxFacetHits,
+      state
+    );
+
     this._currentNbQueries++;
     // eslint-disable-next-line consistent-this
     var self = this;
     var searchForFacetValuesPromise;
     // newer algoliasearch ^3.27.1 - ~4.0.0
     if (clientHasSFFV) {
-      searchForFacetValuesPromise = this.client.searchForFacetValues([{
-        indexName: state.index,
-        params: algoliaQuery
-      }]);
+      searchForFacetValuesPromise = this.client.searchForFacetValues([
+        { indexName: state.index, params: algoliaQuery },
+      ]);
       // algoliasearch < 3.27.1
     } else if (clientHasInitIndex) {
-      searchForFacetValuesPromise = this.client.initIndex(state.index).searchForFacetValues(algoliaQuery);
+      searchForFacetValuesPromise = this.client
+        .initIndex(state.index)
+        .searchForFacetValues(algoliaQuery);
       // algoliasearch ~5.0.0
     } else {
       // @MAJOR only use client.search
       delete algoliaQuery.facetName;
-      searchForFacetValuesPromise = this.client.search([{
-        type: 'facet',
-        facet: facet,
-        indexName: state.index,
-        params: algoliaQuery
-      }]).then(function processResponse(response) {
-        return response.results[0];
-      });
+      searchForFacetValuesPromise = this.client
+        .search([
+          {
+            type: 'facet',
+            facet: facet,
+            indexName: state.index,
+            params: algoliaQuery,
+          },
+        ])
+        .then(function processResponse(response) {
+          return response.results[0];
+        });
     }
+
     this.emit('searchForFacetValues', {
       state: state,
       facet: facet,
-      query: query
-    });
-    return searchForFacetValuesPromise.then(function addIsRefined(content) {
-      self._currentNbQueries--;
-      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
-      content = Array.isArray(content) ? content[0] : content;
-      content.facetHits.forEach(function (f) {
-        f.escapedValue = escapeFacetValue$4(f.value);
-        f.isRefined = isDisjunctive ? state.isDisjunctiveFacetRefined(facet, f.escapedValue) : state.isFacetRefined(facet, f.escapedValue);
-      });
-      return content;
-    }, function (e) {
-      self._currentNbQueries--;
-      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
-      throw e;
+      query: query,
     });
+
+    return searchForFacetValuesPromise.then(
+      function addIsRefined(content) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
+
+        content = Array.isArray(content) ? content[0] : content;
+
+        content.facetHits.forEach(function (f) {
+          f.escapedValue = escapeFacetValue$4(f.value);
+          f.isRefined = isDisjunctive
+            ? state.isDisjunctiveFacetRefined(facet, f.escapedValue)
+            : state.isFacetRefined(facet, f.escapedValue);
+        });
+
+        return content;
+      },
+      function (e) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
+        throw e;
+      }
+    );
   };
 
   /**
@@ -9435,8 +10309,9 @@
   AlgoliaSearchHelper.prototype.setQuery = function (q) {
     this._change({
       state: this.state.resetPage().setQuery(q),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9466,8 +10341,9 @@
   AlgoliaSearchHelper.prototype.clearRefinements = function (name) {
     this._change({
       state: this.state.resetPage().clearRefinements(name),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9482,8 +10358,9 @@
   AlgoliaSearchHelper.prototype.clearTags = function () {
     this._change({
       state: this.state.resetPage().clearTags(),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9498,11 +10375,15 @@
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function (facet, value) {
+  AlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function (
+    facet,
+    value
+  ) {
     this._change({
       state: this.state.resetPage().addDisjunctiveFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9527,11 +10408,15 @@
    * @chainable
    * @fires change
    */
-  AlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function (facet, path) {
+  AlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function (
+    facet,
+    path
+  ) {
     this._change({
       state: this.state.resetPage().addHierarchicalFacetRefinement(facet, path),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9547,11 +10432,18 @@
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addNumericRefinement = function (attribute, operator, value) {
+  AlgoliaSearchHelper.prototype.addNumericRefinement = function (
+    attribute,
+    operator,
+    value
+  ) {
     this._change({
-      state: this.state.resetPage().addNumericRefinement(attribute, operator, value),
-      isPageReset: true
+      state: this.state
+        .resetPage()
+        .addNumericRefinement(attribute, operator, value),
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9569,8 +10461,9 @@
   AlgoliaSearchHelper.prototype.addFacetRefinement = function (facet, value) {
     this._change({
       state: this.state.resetPage().addFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9596,8 +10489,9 @@
   AlgoliaSearchHelper.prototype.addFacetExclusion = function (facet, value) {
     this._change({
       state: this.state.resetPage().addExcludeRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9622,8 +10516,9 @@
   AlgoliaSearchHelper.prototype.addTag = function (tag) {
     this._change({
       state: this.state.resetPage().addTagRefinement(tag),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9645,11 +10540,18 @@
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeNumericRefinement = function (attribute, operator, value) {
+  AlgoliaSearchHelper.prototype.removeNumericRefinement = function (
+    attribute,
+    operator,
+    value
+  ) {
     this._change({
-      state: this.state.resetPage().removeNumericRefinement(attribute, operator, value),
-      isPageReset: true
+      state: this.state
+        .resetPage()
+        .removeNumericRefinement(attribute, operator, value),
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9667,11 +10569,17 @@
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function (facet, value) {
+  AlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function (
+    facet,
+    value
+  ) {
     this._change({
-      state: this.state.resetPage().removeDisjunctiveFacetRefinement(facet, value),
-      isPageReset: true
+      state: this.state
+        .resetPage()
+        .removeDisjunctiveFacetRefinement(facet, value),
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9691,11 +10599,14 @@
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function (facet) {
+  AlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function (
+    facet
+  ) {
     this._change({
       state: this.state.resetPage().removeHierarchicalFacetRefinement(facet),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9716,8 +10627,9 @@
   AlgoliaSearchHelper.prototype.removeFacetRefinement = function (facet, value) {
     this._change({
       state: this.state.resetPage().removeFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9746,8 +10658,9 @@
   AlgoliaSearchHelper.prototype.removeFacetExclusion = function (facet, value) {
     this._change({
       state: this.state.resetPage().removeExcludeRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9772,8 +10685,9 @@
   AlgoliaSearchHelper.prototype.removeTag = function (tag) {
     this._change({
       state: this.state.resetPage().removeTagRefinement(tag),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9791,8 +10705,9 @@
   AlgoliaSearchHelper.prototype.toggleFacetExclusion = function (facet, value) {
     this._change({
       state: this.state.resetPage().toggleExcludeFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9840,8 +10755,9 @@
   AlgoliaSearchHelper.prototype.toggleFacetRefinement = function (facet, value) {
     this._change({
       state: this.state.resetPage().toggleFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9866,8 +10782,9 @@
   AlgoliaSearchHelper.prototype.toggleTag = function (tag) {
     this._change({
       state: this.state.resetPage().toggleTagRefinement(tag),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9908,10 +10825,12 @@
    */
   function setCurrentPage(page) {
     if (page < 0) throw new Error('Page requested below 0.');
+
     this._change({
       state: this.state.setPage(page),
-      isPageReset: false
+      isPageReset: false,
     });
+
     return this;
   }
 
@@ -9947,8 +10866,9 @@
   AlgoliaSearchHelper.prototype.setIndex = function (name) {
     this._change({
       state: this.state.resetPage().setIndex(name),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9972,8 +10892,9 @@
   AlgoliaSearchHelper.prototype.setQueryParameter = function (parameter, value) {
     this._change({
       state: this.state.resetPage().setQueryParameter(parameter, value),
-      isPageReset: true
+      isPageReset: true,
     });
+
     return this;
   };
 
@@ -9987,8 +10908,9 @@
   AlgoliaSearchHelper.prototype.setState = function (newState) {
     this._change({
       state: SearchParameters_1.make(newState),
-      isPageReset: false
+      isPageReset: false,
     });
+
     return this;
   };
 
@@ -10009,10 +10931,11 @@
    *  }
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function (newState) {
-    this.state = new SearchParameters_1(newState);
-    return this;
-  };
+  AlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent =
+    function (newState) {
+      this.state = new SearchParameters_1(newState);
+      return this;
+    };
 
   /**
    * Check if an attribute has any numeric, conjunctive, disjunctive or hierarchical filters.
@@ -10114,6 +11037,7 @@
   AlgoliaSearchHelper.prototype.getIndex = function () {
     return this.state.index;
   };
+
   function getCurrentPage() {
     return this.state.page;
   }
@@ -10186,39 +11110,49 @@
    */
   AlgoliaSearchHelper.prototype.getRefinements = function (facetName) {
     var refinements = [];
+
     if (this.state.isConjunctiveFacet(facetName)) {
       var conjRefinements = this.state.getConjunctiveRefinements(facetName);
+
       conjRefinements.forEach(function (r) {
         refinements.push({
           value: r,
-          type: 'conjunctive'
+          type: 'conjunctive',
         });
       });
+
       var excludeRefinements = this.state.getExcludeRefinements(facetName);
+
       excludeRefinements.forEach(function (r) {
         refinements.push({
           value: r,
-          type: 'exclude'
+          type: 'exclude',
         });
       });
     } else if (this.state.isDisjunctiveFacet(facetName)) {
-      var disjunctiveRefinements = this.state.getDisjunctiveRefinements(facetName);
+      var disjunctiveRefinements =
+        this.state.getDisjunctiveRefinements(facetName);
+
       disjunctiveRefinements.forEach(function (r) {
         refinements.push({
           value: r,
-          type: 'disjunctive'
+          type: 'disjunctive',
         });
       });
     }
+
     var numericRefinements = this.state.getNumericRefinements(facetName);
+
     Object.keys(numericRefinements).forEach(function (operator) {
       var value = numericRefinements[operator];
+
       refinements.push({
         value: value,
         operator: operator,
-        type: 'numeric'
+        type: 'numeric',
       });
     });
+
     return refinements;
   };
 
@@ -10228,7 +11162,10 @@
    * @param {string} operator operator applied on the refined values
    * @return {Array.<number|number[]>} refined values
    */
-  AlgoliaSearchHelper.prototype.getNumericRefinement = function (attribute, operator) {
+  AlgoliaSearchHelper.prototype.getNumericRefinement = function (
+    attribute,
+    operator
+  ) {
     return this.state.getNumericRefinement(attribute, operator);
   };
 
@@ -10237,7 +11174,9 @@
    * @param  {string} facetName Hierarchical facet name
    * @return {array.<string>} the path as an array of string
    */
-  AlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function (facetName) {
+  AlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function (
+    facetName
+  ) {
     return this.state.getHierarchicalFacetBreadcrumb(facetName);
   };
 
@@ -10257,48 +11196,65 @@
     var state = this.state;
     var states = [];
     var mainQueries = [];
+
     if (!options.onlyWithDerivedHelpers) {
       mainQueries = requestBuilder_1._getQueries(state.index, state);
+
       states.push({
         state: state,
         queriesCount: mainQueries.length,
-        helper: this
+        helper: this,
       });
+
       this.emit('search', {
         state: state,
-        results: this.lastResults
+        results: this.lastResults,
       });
     }
+
     var derivedQueries = this.derivedHelpers.map(function (derivedHelper) {
       var derivedState = derivedHelper.getModifiedState(state);
-      var derivedStateQueries = derivedState.index ? requestBuilder_1._getQueries(derivedState.index, derivedState) : [];
+      var derivedStateQueries = derivedState.index
+        ? requestBuilder_1._getQueries(derivedState.index, derivedState)
+        : [];
+
       states.push({
         state: derivedState,
         queriesCount: derivedStateQueries.length,
-        helper: derivedHelper
+        helper: derivedHelper,
       });
+
       derivedHelper.emit('search', {
         state: derivedState,
-        results: derivedHelper.lastResults
+        results: derivedHelper.lastResults,
       });
+
       return derivedStateQueries;
     });
+
     var queries = Array.prototype.concat.apply(mainQueries, derivedQueries);
+
     var queryId = this._queryId++;
     this._currentNbQueries++;
+
     if (!queries.length) {
-      return Promise.resolve({
-        results: []
-      }).then(this._dispatchAlgoliaResponse.bind(this, states, queryId));
+      return Promise.resolve({ results: [] }).then(
+        this._dispatchAlgoliaResponse.bind(this, states, queryId)
+      );
     }
+
     try {
-      this.client.search(queries).then(this._dispatchAlgoliaResponse.bind(this, states, queryId)).catch(this._dispatchAlgoliaError.bind(this, queryId));
+      this.client
+        .search(queries)
+        .then(this._dispatchAlgoliaResponse.bind(this, states, queryId))
+        .catch(this._dispatchAlgoliaError.bind(this, queryId));
     } catch (error) {
       // If we reach this part, we're in an internal error state
       this.emit('error', {
-        error: error
+        error: error,
       });
     }
+
     return undefined;
   };
 
@@ -10312,50 +11268,79 @@
    * @param {object} content content of the response
    * @return {undefined}
    */
-  AlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function (states, queryId, content) {
+  AlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function (
+    states,
+    queryId,
+    content
+  ) {
     // @TODO remove the number of outdated queries discarded instead of just one
 
     if (queryId < this._lastQueryIdReceived) {
       // Outdated answer
       return;
     }
+
     this._currentNbQueries -= queryId - this._lastQueryIdReceived;
     this._lastQueryIdReceived = queryId;
+
     if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');
+
     var results = content.results.slice();
+
     states.forEach(function (s) {
       var state = s.state;
       var queriesCount = s.queriesCount;
       var helper = s.helper;
       var specificResults = results.splice(0, queriesCount);
+
       if (!state.index) {
         helper.emit('result', {
           results: null,
-          state: state
+          state: state,
         });
         return;
       }
+
       helper.lastResults = new SearchResults_1(state, specificResults);
+
       helper.emit('result', {
         results: helper.lastResults,
-        state: state
+        state: state,
       });
     });
   };
-  AlgoliaSearchHelper.prototype._dispatchAlgoliaError = function (queryId, error) {
+
+  AlgoliaSearchHelper.prototype._dispatchAlgoliaError = function (
+    queryId,
+    error
+  ) {
     if (queryId < this._lastQueryIdReceived) {
       // Outdated answer
       return;
     }
+
     this._currentNbQueries -= queryId - this._lastQueryIdReceived;
     this._lastQueryIdReceived = queryId;
+
     this.emit('error', {
-      error: error
+      error: error,
     });
+
     if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');
   };
-  AlgoliaSearchHelper.prototype.containsRefinement = function (query, facetFilters, numericFilters, tagFilters) {
-    return query || facetFilters.length !== 0 || numericFilters.length !== 0 || tagFilters.length !== 0;
+
+  AlgoliaSearchHelper.prototype.containsRefinement = function (
+    query,
+    facetFilters,
+    numericFilters,
+    tagFilters
+  ) {
+    return (
+      query ||
+      facetFilters.length !== 0 ||
+      numericFilters.length !== 0 ||
+      tagFilters.length !== 0
+    );
   };
 
   /**
@@ -10365,17 +11350,23 @@
    * @return {boolean} true if there are refinements on this attribute
    */
   AlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function (facet) {
-    return this.state.disjunctiveRefinements[facet] && this.state.disjunctiveRefinements[facet].length > 0;
+    return (
+      this.state.disjunctiveRefinements[facet] &&
+      this.state.disjunctiveRefinements[facet].length > 0
+    );
   };
+
   AlgoliaSearchHelper.prototype._change = function (event) {
     var state = event.state;
     var isPageReset = event.isPageReset;
+
     if (state !== this.state) {
       this.state = state;
+
       this.emit('change', {
         state: this.state,
         results: this.lastResults,
-        isPageReset: isPageReset
+        isPageReset: isPageReset,
       });
     }
   };
@@ -10397,10 +11388,12 @@
    */
   AlgoliaSearchHelper.prototype.setClient = function (newClient) {
     if (this.client === newClient) return this;
+
     if (typeof newClient.addAlgoliaAgent === 'function') {
       newClient.addAlgoliaAgent('JS Helper (' + version + ')');
     }
     this.client = newClient;
+
     return this;
   };
 
@@ -10539,6 +11532,7 @@
    * @type {SearchResults}
    */
   algoliasearchHelper.SearchResults = SearchResults_1;
+
   var algoliasearchHelper_1 = algoliasearchHelper;
 
   var withUsage$l = createDocumentationMessageGenerator({
@@ -11893,7 +12887,7 @@
       return obj;
   };
 
-  var merge$2 = function merge(target, source, options) {
+  var merge$1 = function merge(target, source, options) {
       /* eslint no-param-reassign: 0 */
       if (!source) {
           return target;
@@ -12097,7 +13091,7 @@
       isBuffer: isBuffer,
       isRegExp: isRegExp,
       maybeMap: maybeMap,
-      merge: merge$2
+      merge: merge$1
   };
 
   var has$1 = Object.prototype.hasOwnProperty;
@@ -13588,7 +14582,7 @@
     };
   }
 
-  var version$1 = '4.56.6';
+  var version$1 = '4.56.7';
 
   var withUsage$r = createDocumentationMessageGenerator({
     name: 'instantsearch'