instantsearch.js 4.56.4 → 4.56.6

package/dist/instantsearch.development.js

@@ -1,4 +1,4 @@
-/*! InstantSearch.js 4.56.4 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch.js */
+/*! InstantSearch.js 4.56.6 | © 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) :
@@ -2395,6 +2395,7 @@
           });
         },
         getWidgetRenderState: function getWidgetRenderState(_ref4) {
+          var _this = this;
           var results = _ref4.results,
             state = _ref4.state,
             createURL = _ref4.createURL,
@@ -2404,9 +2405,14 @@
           var canToggleShowMore = false;
 
           // Bind createURL to this specific attribute
-          function _createURL(facetValue) {
-            return createURL(state.resetPage().toggleFacetRefinement(hierarchicalFacetName, facetValue));
-          }
+          var _createURL = function _createURL(facetValue) {
+            return createURL(function (uiState) {
+              return _this.getWidgetUiState(uiState, {
+                searchParameters: state.resetPage().toggleFacetRefinement(hierarchicalFacetName, facetValue),
+                helper: helper
+              });
+            });
+          };
           if (!sendEvent) {
             sendEvent = createSendEventForFacet({
               instantSearchInstance: instantSearchInstance,
@@ -2843,9 +2849,16 @@
         },
         createURLFactory: function createURLFactory(_ref3) {
           var state = _ref3.state,
-            createURL = _ref3.createURL;
+            createURL = _ref3.createURL,
+            getWidgetUiState = _ref3.getWidgetUiState,
+            helper = _ref3.helper;
           return function (value) {
-            return createURL(state.resetPage().setQueryParameter('hitsPerPage', !value && value !== 0 ? undefined : value));
+            return createURL(function (uiState) {
+              return getWidgetUiState(uiState, {
+                searchParameters: state.resetPage().setQueryParameter('hitsPerPage', !value && value !== 0 ? undefined : value),
+                helper: helper
+              });
+            });
           };
         }
       };
@@ -2900,7 +2913,9 @@
             refine: connectorState.getRefine(helper),
             createURL: connectorState.createURLFactory({
               state: state,
-              createURL: createURL
+              createURL: createURL,
+              getWidgetUiState: this.getWidgetUiState,
+              helper: helper
             }),
             hasNoResults: !canRefine,
             canRefine: canRefine,
@@ -3258,6 +3273,7 @@
           });
         },
         getWidgetRenderState: function getWidgetRenderState(renderOptions) {
+          var _this = this;
           var results = renderOptions.results,
             createURL = renderOptions.createURL,
             instantSearchInstance = renderOptions.instantSearchInstance,
@@ -3274,7 +3290,12 @@
           }
           if (!_createURL) {
             _createURL = function _createURL(facetValue) {
-              return createURL(helper.state.resetPage().toggleFacetRefinement(attribute, facetValue));
+              return createURL(function (uiState) {
+                return _this.getWidgetUiState(uiState, {
+                  searchParameters: helper.state.resetPage().toggleFacetRefinement(attribute, facetValue),
+                  helper: helper
+                });
+              });
             };
           }
           if (!_refine) {
@@ -3475,6 +3496,7 @@
           });
         },
         getWidgetRenderState: function getWidgetRenderState(_ref7) {
+          var _this = this;
           var results = _ref7.results,
             state = _ref7.state,
             instantSearchInstance = _ref7.instantSearchInstance,
@@ -3490,7 +3512,12 @@
           if (!connectorState.createURL) {
             connectorState.createURL = function (newState) {
               return function (facetValue) {
-                return createURL(getRefinedState(newState, attribute, facetValue));
+                return createURL(function (uiState) {
+                  return _this.getWidgetUiState(uiState, {
+                    searchParameters: getRefinedState(newState, attribute, facetValue),
+                    helper: helper
+                  });
+                });
               };
             };
           }
@@ -3740,10 +3767,12 @@
             };
           }
           if (!connectorState.createURL) {
-            connectorState.createURL = function (helperState) {
-              return function (page) {
-                return createURL(helperState.setPage(page));
-              };
+            connectorState.createURL = function (page) {
+              return createURL(function (uiState) {
+                return _objectSpread2(_objectSpread2({}, uiState), {}, {
+                  page: page
+                });
+              });
             };
           }
           var page = state.page || 0;
@@ -3753,7 +3782,7 @@
           pager.currentPage = page;
           pager.total = nbPages;
           return {
-            createURL: connectorState.createURL(state),
+            createURL: connectorState.createURL,
             refine: connectorState.refine,
             canRefine: nbPages > 1,
             currentRefinement: page,
@@ -4196,6 +4225,7 @@
           });
         },
         getWidgetRenderState: function getWidgetRenderState(renderOptions) {
+          var _this = this;
           var results = renderOptions.results,
             state = renderOptions.state,
             _createURL = renderOptions.createURL,
@@ -4249,7 +4279,12 @@
           var canToggleShowMore = canShowLess || canShowMore;
           return {
             createURL: function createURL(facetValue) {
-              return _createURL(state.resetPage().toggleFacetRefinement(attribute, facetValue));
+              return _createURL(function (uiState) {
+                return _this.getWidgetUiState(uiState, {
+                  searchParameters: state.resetPage().toggleFacetRefinement(attribute, facetValue),
+                  helper: helper
+                });
+              });
             },
             items: items,
             refine: triggerRefine,
@@ -4615,9 +4650,16 @@
         },
         createURLFactory: function createURLFactory(_ref4) {
           var state = _ref4.state,
-            createURL = _ref4.createURL;
+            createURL = _ref4.createURL,
+            getWidgetUiState = _ref4.getWidgetUiState,
+            helper = _ref4.helper;
           return function (value) {
-            return createURL(getRefinedState(state, value));
+            return createURL(function (uiState) {
+              return getWidgetUiState(uiState, {
+                searchParameters: getRefinedState(state, value),
+                helper: helper
+              });
+            });
           };
         }
       };
@@ -4713,7 +4755,9 @@
             sendEvent: sendEvent,
             createURL: connectorState.createURLFactory({
               state: state,
-              createURL: createURL
+              createURL: createURL,
+              helper: helper,
+              getWidgetUiState: this.getWidgetUiState
             }),
             widgetParams: widgetParams
           };
@@ -4925,7 +4969,9 @@
       var connectorState = {
         createURLFactory: function createURLFactory(isRefined, _ref4) {
           var state = _ref4.state,
-            createURL = _ref4.createURL;
+            createURL = _ref4.createURL,
+            getWidgetUiState = _ref4.getWidgetUiState,
+            helper = _ref4.helper;
           return function () {
             state = state.resetPage();
             var valuesToRemove = isRefined ? on : off;
@@ -4940,7 +4986,12 @@
                 state = state.addDisjunctiveFacetRefinement(attribute, v);
               });
             }
-            return createURL(state);
+            return createURL(function (uiState) {
+              return getWidgetUiState(uiState, {
+                searchParameters: state,
+                helper: helper
+              });
+            });
           };
         }
       };
@@ -5045,7 +5096,9 @@
             },
             createURL: connectorState.createURLFactory(isRefined, {
               state: state,
-              createURL: createURL
+              createURL: createURL,
+              helper: helper,
+              getWidgetUiState: this.getWidgetUiState
             }),
             sendEvent: sendEvent,
             canRefine: Boolean(results ? nextRefinement.count : null),
@@ -5059,6 +5112,9 @@
             return searchParameters.isDisjunctiveFacetRefined(attribute, v);
           });
           if (!isRefined) {
+            var _uiState$toggle;
+            // This needs to be done in the case `uiState` comes from `createURL`
+            (_uiState$toggle = uiState.toggle) === null || _uiState$toggle === void 0 ? true : delete _uiState$toggle[attribute];
             return uiState;
           }
           return _objectSpread2(_objectSpread2({}, uiState), {}, {
@@ -5157,6 +5213,7 @@
           });
         },
         getWidgetRenderState: function getWidgetRenderState(_ref2) {
+          var _this = this;
           var helper = _ref2.helper,
             createURL = _ref2.createURL,
             results = _ref2.results,
@@ -5180,7 +5237,12 @@
           var items = getItems();
           if (!connectorState.createURL) {
             connectorState.createURL = function (facetValue) {
-              return createURL(getRefinedState(helper.state, facetValue));
+              return createURL(function (uiState) {
+                return _this.getWidgetUiState(uiState, {
+                  searchParameters: getRefinedState(helper.state, facetValue),
+                  helper: helper
+                });
+              });
             };
           }
           if (!connectorState.refine) {
@@ -5196,18 +5258,39 @@
             widgetParams: widgetParams
           };
         },
-        getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters) {
+        getWidgetUiState: function getWidgetUiState(uiState, _ref3) {
+          var searchParameters = _ref3.searchParameters;
+          var path = searchParameters.getHierarchicalFacetBreadcrumb(hierarchicalFacetName);
+          if (!path.length) {
+            return uiState;
+          }
+          return _objectSpread2(_objectSpread2({}, uiState), {}, {
+            hierarchicalMenu: _objectSpread2(_objectSpread2({}, uiState.hierarchicalMenu), {}, _defineProperty({}, hierarchicalFacetName, path))
+          });
+        },
+        getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, _ref4) {
+          var uiState = _ref4.uiState;
+          var values = uiState.hierarchicalMenu && uiState.hierarchicalMenu[hierarchicalFacetName];
+          if (searchParameters.isConjunctiveFacet(hierarchicalFacetName) || searchParameters.isDisjunctiveFacet(hierarchicalFacetName)) {
+             _warning(false, "HierarchicalMenu: Attribute \"".concat(hierarchicalFacetName, "\" is already used by another widget applying conjunctive or disjunctive faceting.\nAs this is not supported, please make sure to remove this other widget or this HierarchicalMenu widget will not work at all.")) ;
+            return searchParameters;
+          }
           if (searchParameters.isHierarchicalFacet(hierarchicalFacetName)) {
             var facet = searchParameters.getHierarchicalFacetByName(hierarchicalFacetName);
              _warning(isEqual(facet.attributes, attributes) && facet.separator === separator && facet.rootPath === rootPath, 'Using Breadcrumb and HierarchicalMenu on the same facet with different options overrides the configuration of the HierarchicalMenu.') ;
-            return searchParameters;
           }
-          return searchParameters.addHierarchicalFacet({
+          var withFacetConfiguration = searchParameters.removeHierarchicalFacet(hierarchicalFacetName).addHierarchicalFacet({
             name: hierarchicalFacetName,
             attributes: attributes,
             separator: separator,
             rootPath: rootPath
           });
+          if (!values) {
+            return withFacetConfiguration.setQueryParameters({
+              hierarchicalFacetsRefinements: _objectSpread2(_objectSpread2({}, withFacetConfiguration.hierarchicalFacetsRefinements), {}, _defineProperty({}, hierarchicalFacetName, []))
+            });
+          }
+          return withFacetConfiguration.addHierarchicalFacetRefinement(hierarchicalFacetName, values.join(separator));
         }
       };
     };
@@ -5488,45 +5571,32 @@
   };
 
   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;
     }
 
+    // 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);
@@ -5546,35 +5616,34 @@
    * - treats sparse arrays as sparse
    * - does not convert Array-like objects (Arguments, NodeLists, etc.) to arrays
    *
-   * @param {Object} object The destination object.
+   * @param {Object} target The destination object.
    * @param {...Object} [sources] The source objects.
    * @returns {Object} Returns `object`.
    */
-
   function merge(target) {
     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 = merge;
+  var merge$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null
+  });
 
   // 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) {
+    return sources.reduceRight(function (acc, source) {
+      Object.keys(Object(source)).forEach(function (key) {
         if (source[key] === undefined) {
           return;
         }
@@ -5589,11 +5658,8 @@
   };
 
   function intersection(arr1, arr2) {
-    return arr1.filter(function(value, index) {
-      return (
-        arr2.indexOf(value) > -1 &&
-        arr1.indexOf(value) === index /* skips duplicates */
-      );
+    return arr1.filter(function (value, index) {
+      return arr2.indexOf(value) > -1 && arr1.indexOf(value) === index /* skips duplicates */;
     });
   }
 
@@ -5604,12 +5670,12 @@
     if (!Array.isArray(array)) {
       return undefined;
     }
-
     for (var i = 0; i < array.length; i++) {
       if (comparator(array[i])) {
         return array[i];
       }
     }
+    return undefined;
   };
 
   function valToNumber(v) {
@@ -5620,10 +5686,8 @@
     } 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.');
   }
-
   var valToNumber_1 = valToNumber;
 
   // https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620
@@ -5635,18 +5699,17 @@
     var i;
     for (i = 0; i < sourceKeys.length; i++) {
       key = sourceKeys[i];
+      // eslint-disable-next-line no-continue
       if (excluded.indexOf(key) >= 0) continue;
       target[key] = source[key];
     }
     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) {
@@ -5670,8 +5733,6 @@
 
 
 
-
-
   var lib = {
     /**
      * Adds a refinement to a RefinementList
@@ -5684,17 +5745,10 @@
       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);
     },
     /**
@@ -5710,14 +5764,12 @@
       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
-        return lib.clearRefinement(refinementList, function(v, f) {
+        return lib.clearRefinement(refinementList, function (v, f) {
           return attribute === f;
         });
       }
-
       var valueAsString = '' + value;
-
-      return lib.clearRefinement(refinementList, function(v, f) {
+      return lib.clearRefinement(refinementList, function (v, f) {
         return attribute === f && valueAsString === v;
       });
     },
@@ -5730,11 +5782,9 @@
      */
     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);
     },
     /**
@@ -5750,6 +5800,8 @@
      */
     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
         if (!objectHasKeys_1(refinementList)) {
           return refinementList;
         }
@@ -5758,24 +5810,24 @@
         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) {
+          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;
       }
+
+      // We return nothing if the attribute is not undefined, a string or a function,
+      // as it is not a valid value for a refinement
+      return undefined;
     },
     /**
      * Test if the refinement value is used for the attribute. If no refinement value
@@ -5784,22 +5836,17 @@
      * @param {RefinementList} refinementList the list of refinement
      * @param {string} attribute name of the attribute
      * @param {string} [refinementValue] value of the filter/refinement
-     * @return {boolean}
+     * @return {boolean} true if the attribute is refined, false otherwise
      */
     isRefined: function isRefined(refinementList, attribute, refinementValue) {
-      var containsRefinements = !!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;
 
   /**
@@ -5808,15 +5855,15 @@
    * - [5]
    * - [[5]]
    * - [[5,5],[4]]
+   * @param {any} a numeric refinement value
+   * @param {any} b numeric refinement value
+   * @return {boolean} true if the values are equal
    */
   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;
   }
@@ -5830,7 +5877,7 @@
    * @return {any} the searched value or undefined
    */
   function findArray(array, searchedValue) {
-    return find$1(array, function(currentValue) {
+    return find$1(array, function (currentValue) {
       return isEqualNumericRefinement(currentValue, searchedValue);
     });
   }
@@ -5884,8 +5931,8 @@
    */
   function SearchParameters(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}');
     }
     /**
@@ -5988,11 +6035,11 @@
      */
     this.hierarchicalFacetsRefinements = params.hierarchicalFacetsRefinements || {};
 
+    // eslint-disable-next-line consistent-this
     var self = this;
-    Object.keys(params).forEach(function(paramName) {
+    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];
       }
@@ -6011,27 +6058,12 @@
    * @param {object} partialState full or part of a state
    * @return {object} a new object with the number keys as number
    */
-  SearchParameters._parseNumbers = function(partialState) {
-    // Do not reparse numbers in SearchParameters, they ought to be parsed already
+  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'
-    ];
-
-    numberKeys.forEach(function(k) {
+    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') {
         var parsedValue = parseFloat(value);
@@ -6043,26 +6075,25 @@
     // 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 geoRect.map(function (value) {
             return parseFloat(value);
           });
         }
         return geoRect;
       });
     }
-
     if (partialState.numericRefinements) {
       var numericRefinements = {};
-      Object.keys(partialState.numericRefinements).forEach(function(attribute) {
+      Object.keys(partialState.numericRefinements).forEach(function (attribute) {
         var operators = partialState.numericRefinements[attribute] || {};
         numericRefinements[attribute] = {};
-        Object.keys(operators).forEach(function(operator) {
+        Object.keys(operators).forEach(function (operator) {
           var values = operators[operator];
-          var parsedValues = values.map(function(v) {
+          var parsedValues = values.map(function (v) {
             if (Array.isArray(v)) {
-              return v.map(function(vPrime) {
+              return v.map(function (vPrime) {
                 if (typeof vPrime === 'string') {
                   return parseFloat(vPrime);
                 }
@@ -6078,8 +6109,7 @@
       });
       numbers.numericRefinements = numericRefinements;
     }
-
-    return merge_1({}, partialState, numbers);
+    return merge$1({}, partialState, numbers);
   };
 
   /**
@@ -6090,12 +6120,10 @@
    */
   SearchParameters.make = function makeSearchParameters(newParameters) {
     var instance = new SearchParameters(newParameters);
-
     var hierarchicalFacets = newParameters.hierarchicalFacets || [];
-    hierarchicalFacets.forEach(function(facet) {
+    hierarchicalFacets.forEach(function (facet) {
       if (facet.rootPath) {
         var currentRefinement = instance.getHierarchicalRefinement(facet.name);
-
         if (currentRefinement.length > 0 && currentRefinement[0].indexOf(facet.rootPath) !== 0) {
           instance = instance.clearRefinements(facet.name);
         }
@@ -6107,7 +6135,6 @@
         }
       }
     });
-
     return instance;
   };
 
@@ -6117,46 +6144,24 @@
    * @param {object|SearchParameters} parameters the new parameters to set
    * @return {Error|null} Error if the modification is invalid, null otherwise
    */
-  SearchParameters.validate = function(currentState, parameters) {
+  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.');
+      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
@@ -6164,39 +6169,17 @@
      * - If not given, means to clear all the filters.
      * - If `string`, means to clear all refinements for the `attribute` named filter.
      * - If `function`, means to clear all the refinements that return truthy values.
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance with filters cleared
      */
     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);
@@ -6204,11 +6187,10 @@
     /**
      * Remove all the refined tags from the SearchParameters
      * @method
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance with tags cleared
      */
     clearTags: function clearTags() {
       if (this.tagFilters === undefined && this.tagRefinements.length === 0) return this;
-
       return this.setQueryParameters({
         tagFilters: undefined,
         tagRefinements: []
@@ -6218,11 +6200,10 @@
      * Set the index.
      * @method
      * @param {string} index the index name
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setIndex: function setIndex(index) {
       if (index === this.index) return this;
-
       return this.setQueryParameters({
         index: index
       });
@@ -6231,11 +6212,10 @@
      * Query setter
      * @method
      * @param {string} newQuery value for the new query
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setQuery: function setQuery(newQuery) {
       if (newQuery === this.query) return this;
-
       return this.setQueryParameters({
         query: newQuery
       });
@@ -6244,11 +6224,10 @@
      * Page setter
      * @method
      * @param {number} newPage new page number
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setPage: function setPage(newPage) {
       if (newPage === this.page) return this;
-
       return this.setQueryParameters({
         page: newPage
       });
@@ -6258,7 +6237,7 @@
      * The facets are the simple facets, used for conjunctive (and) faceting.
      * @method
      * @param {string[]} facets all the attributes of the algolia records used for conjunctive faceting
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setFacets: function setFacets(facets) {
       return this.setQueryParameters({
@@ -6270,7 +6249,7 @@
      * Change the list of disjunctive (or) facets the helper chan handle.
      * @method
      * @param {string[]} facets all the attributes of the algolia records used for disjunctive faceting
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setDisjunctiveFacets: function setDisjunctiveFacets(facets) {
       return this.setQueryParameters({
@@ -6282,11 +6261,10 @@
      * Hits per page represents the number of hits retrieved for this query
      * @method
      * @param {number} n number of hits retrieved per page of results
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setHitsPerPage: function setHitsPerPage(n) {
       if (this.hitsPerPage === n) return this;
-
       return this.setQueryParameters({
         hitsPerPage: n
       });
@@ -6296,11 +6274,10 @@
      * Set the value of typoTolerance
      * @method
      * @param {string} typoTolerance new value of typoTolerance ("true", "false", "min" or "strict")
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setTypoTolerance: function setTypoTolerance(typoTolerance) {
       if (this.typoTolerance === typoTolerance) return this;
-
       return this.setQueryParameters({
         typoTolerance: typoTolerance
       });
@@ -6313,33 +6290,28 @@
      * @param {string} attribute attribute to set the filter on
      * @param {string} operator operator of the filter (possible values: =, >, >=, <, <=, !=)
      * @param {number | number[]} value value of the filter
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      * @example
      * // for price = 50 or 40
-     * searchparameter.addNumericRefinement('price', '=', [50, 40]);
+     * state.addNumericRefinement('price', '=', [50, 40]);
      * @example
      * // for size = 38 and 40
-     * searchparameter.addNumericRefinement('size', '=', 38);
-     * searchparameter.addNumericRefinement('size', '=', 40);
+     * state.addNumericRefinement('size', '=', 38);
+     * state.addNumericRefinement('size', '=', 40);
      */
-    addNumericRefinement: function(attribute, operator, v) {
-      var value = valToNumber_1(v);
-
-      if (this.isNumericRefined(attribute, operator, value)) return this;
-
-      var mod = merge_1({}, this.numericRefinements);
-
-      mod[attribute] = merge_1({}, mod[attribute]);
-
+    addNumericRefinement: function addNumericRefinement(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]);
       if (mod[attribute][operator]) {
         // Array copy
         mod[attribute][operator] = mod[attribute][operator].slice();
         // Add the element. Concat can't be used here because value can be an array.
-        mod[attribute][operator].push(value);
+        mod[attribute][operator].push(val);
       } else {
-        mod[attribute][operator] = [value];
+        mod[attribute][operator] = [val];
       }
-
       return this.setQueryParameters({
         numericRefinements: mod
       });
@@ -6349,7 +6321,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getConjunctiveRefinements: function(facetName) {
+    getConjunctiveRefinements: function getConjunctiveRefinements(facetName) {
       if (!this.isConjunctiveFacet(facetName)) {
         return [];
       }
@@ -6360,7 +6332,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getDisjunctiveRefinements: function(facetName) {
+    getDisjunctiveRefinements: function getDisjunctiveRefinements(facetName) {
       if (!this.isDisjunctiveFacet(facetName)) {
         return [];
       }
@@ -6371,7 +6343,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getHierarchicalRefinement: function(facetName) {
+    getHierarchicalRefinement: function getHierarchicalRefinement(facetName) {
       // we send an array but we currently do not support multiple
       // hierarchicalRefinements for a hierarchicalFacet
       return this.hierarchicalFacetsRefinements[facetName] || [];
@@ -6381,47 +6353,42 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getExcludeRefinements: function(facetName) {
+    getExcludeRefinements: function getExcludeRefinements(facetName) {
       if (!this.isConjunctiveFacet(facetName)) {
         return [];
       }
       return this.facetsExcludes[facetName] || [];
     },
-
     /**
      * Remove all the numeric filter for a given (attribute, operator)
      * @method
      * @param {string} attribute attribute to set the filter on
      * @param {string} [operator] operator of the filter (possible values: =, >, >=, <, <=, !=)
      * @param {number} [number] the value to be removed
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
-    removeNumericRefinement: function(attribute, operator, paramValue) {
+    removeNumericRefinement: function removeNumericRefinement(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) {
+        numericRefinements: this._clearNumericRefinements(function (value, key) {
           return key === attribute;
         })
       });
@@ -6431,7 +6398,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {SearchParameters.OperatorList} list of refinements
      */
-    getNumericRefinements: function(facetName) {
+    getNumericRefinements: function getNumericRefinements(facetName) {
       return this.numericRefinements[facetName] || {};
     },
     /**
@@ -6440,7 +6407,7 @@
      * @param {string} operator operator applied on the refined values
      * @return {Array.<number|number[]>} refined values
      */
-    getNumericRefinement: function(attribute, operator) {
+    getNumericRefinement: function getNumericRefinement(attribute, operator) {
       return this.numericRefinements[attribute] && this.numericRefinements[attribute][operator];
     },
     /**
@@ -6451,7 +6418,7 @@
      * - If not given, means to clear all the filters.
      * - If `string`, means to clear all refinements for the `attribute` named filter.
      * - If `function`, means to clear all the refinements that return truthy values.
-     * @return {Object.<string, OperatorList>}
+     * @return {Object.<string, OperatorList>} new numeric refinements
      */
     _clearNumericRefinements: function _clearNumericRefinements(attribute) {
       if (attribute === undefined) {
@@ -6464,16 +6431,18 @@
       } else if (typeof attribute === 'function') {
         var hasChanged = false;
         var numericRefinements = this.numericRefinements;
-        var newNumericRefinements = Object.keys(numericRefinements).reduce(function(memo, key) {
+        var newNumericRefinements = Object.keys(numericRefinements).reduce(function (memo, key) {
           var operators = numericRefinements[key];
           var operatorList = {};
-
           operators = operators || {};
-          Object.keys(operators).forEach(function(operator) {
+          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');
+            values.forEach(function (value) {
+              var predicateResult = attribute({
+                val: value,
+                op: operator
+              }, key, 'numeric');
               if (!predicateResult) outValues.push(value);
             });
             if (outValues.length !== values.length) {
@@ -6481,28 +6450,28 @@
             }
             operatorList[operator] = outValues;
           });
-
           memo[key] = operatorList;
-
           return memo;
         }, {});
-
         if (hasChanged) return newNumericRefinements;
         return this.numericRefinements;
       }
+
+      // We return nothing if the attribute is not undefined, a string or a function,
+      // as it is not a valid value for a refinement
+      return undefined;
     },
     /**
      * Add a facet to the facets attribute of the helper configuration, if it
      * isn't already present.
      * @method
      * @param {string} facet facet name to add
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addFacet: function addFacet(facet) {
       if (this.isConjunctiveFacet(facet)) {
         return this;
       }
-
       return this.setQueryParameters({
         facets: this.facets.concat([facet])
       });
@@ -6512,13 +6481,12 @@
      * configuration, if it isn't already present.
      * @method
      * @param {string} facet disjunctive facet name to add
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addDisjunctiveFacet: function addDisjunctiveFacet(facet) {
       if (this.isDisjunctiveFacet(facet)) {
         return this;
       }
-
       return this.setQueryParameters({
         disjunctiveFacets: this.disjunctiveFacets.concat([facet])
       });
@@ -6528,15 +6496,13 @@
      * configuration.
      * @method
      * @param {object} hierarchicalFacet hierarchical facet to add
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      * @throws will throw an error if a hierarchical facet with the same name was already declared
      */
     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])
       });
@@ -6546,14 +6512,13 @@
      * @method
      * @param {string} facet attribute to apply the faceting on
      * @param {string} value value of the attribute (will be converted to string)
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addFacetRefinement: function addFacetRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
         throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
       }
       if (RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
-
       return this.setQueryParameters({
         facetsRefinements: RefinementList.addRefinement(this.facetsRefinements, facet, value)
       });
@@ -6563,14 +6528,13 @@
      * @method
      * @param {string} facet attribute to apply the exclusion on
      * @param {string} value value of the attribute (will be converted to string)
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addExcludeRefinement: function addExcludeRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
         throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
       }
       if (RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
-
       return this.setQueryParameters({
         facetsExcludes: RefinementList.addRefinement(this.facetsExcludes, facet, value)
       });
@@ -6580,33 +6544,27 @@
      * @method
      * @param {string} facet attribute to apply the faceting on
      * @param {string} value value of the attribute (will be converted to string)
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     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;
-
       return this.setQueryParameters({
-        disjunctiveFacetsRefinements: RefinementList.addRefinement(
-          this.disjunctiveFacetsRefinements, facet, value)
+        disjunctiveFacetsRefinements: RefinementList.addRefinement(this.disjunctiveFacetsRefinements, facet, value)
       });
     },
     /**
      * addTagRefinement adds a tag to the list used to filter the results
      * @param {string} tag tag to be added
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addTagRefinement: function addTagRefinement(tag) {
       if (this.isTagRefined(tag)) return this;
-
       var modification = {
         tagRefinements: this.tagRefinements.concat(tag)
       };
-
       return this.setQueryParameters(modification);
     },
     /**
@@ -6614,15 +6572,14 @@
      * is present.
      * @method
      * @param {string} facet facet name to remove
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeFacet: function removeFacet(facet) {
       if (!this.isConjunctiveFacet(facet)) {
         return this;
       }
-
       return this.clearRefinements(facet).setQueryParameters({
-        facets: this.facets.filter(function(f) {
+        facets: this.facets.filter(function (f) {
           return f !== facet;
         })
       });
@@ -6632,15 +6589,14 @@
      * helper configuration, if it is present.
      * @method
      * @param {string} facet disjunctive facet name to remove
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeDisjunctiveFacet: function removeDisjunctiveFacet(facet) {
       if (!this.isDisjunctiveFacet(facet)) {
         return this;
       }
-
       return this.clearRefinements(facet).setQueryParameters({
-        disjunctiveFacets: this.disjunctiveFacets.filter(function(f) {
+        disjunctiveFacets: this.disjunctiveFacets.filter(function (f) {
           return f !== facet;
         })
       });
@@ -6650,15 +6606,14 @@
      * helper configuration, if it is present.
      * @method
      * @param {string} facet hierarchical facet name to remove
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeHierarchicalFacet: function removeHierarchicalFacet(facet) {
       if (!this.isHierarchicalFacet(facet)) {
         return this;
       }
-
       return this.clearRefinements(facet).setQueryParameters({
-        hierarchicalFacets: this.hierarchicalFacets.filter(function(f) {
+        hierarchicalFacets: this.hierarchicalFacets.filter(function (f) {
           return f.name !== facet;
         })
       });
@@ -6670,14 +6625,13 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {string} [value] value used to filter
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeFacetRefinement: function removeFacetRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
         throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
       }
       if (!RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
-
       return this.setQueryParameters({
         facetsRefinements: RefinementList.removeRefinement(this.facetsRefinements, facet, value)
       });
@@ -6687,14 +6641,13 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {string} value value used to filter
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeExcludeRefinement: function removeExcludeRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
         throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
       }
       if (!RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
-
       return this.setQueryParameters({
         facetsExcludes: RefinementList.removeRefinement(this.facetsExcludes, facet, value)
       });
@@ -6704,35 +6657,30 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {string} value value used to filter
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     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;
-
       return this.setQueryParameters({
-        disjunctiveFacetsRefinements: RefinementList.removeRefinement(
-          this.disjunctiveFacetsRefinements, facet, value)
+        disjunctiveFacetsRefinements: RefinementList.removeRefinement(this.disjunctiveFacetsRefinements, facet, value)
       });
     },
     /**
      * Remove a tag from the list of tag refinements
      * @method
      * @param {string} tag the tag to remove
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeTagRefinement: function removeTagRefinement(tag) {
       if (!this.isTagRefined(tag)) return this;
-
       var modification = {
-        tagRefinements: this.tagRefinements.filter(function(t) {
+        tagRefinements: this.tagRefinements.filter(function (t) {
           return t !== tag;
         })
       };
-
       return this.setQueryParameters(modification);
     },
     /**
@@ -6740,7 +6688,7 @@
      * and hierarchical facets
      * @param  {string} facet the facet to refine
      * @param  {string} value the associated value
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      * @throws will throw an error if the facet is not declared in the settings of the helper
      * @deprecated since version 2.19.0, see {@link SearchParameters#toggleFacetRefinement}
      */
@@ -6752,7 +6700,7 @@
      * and hierarchical facets
      * @param  {string} facet the facet to refine
      * @param  {string} value the associated value
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      * @throws will throw an error if the facet is not declared in the settings of the helper
      */
     toggleFacetRefinement: function toggleFacetRefinement(facet, value) {
@@ -6763,22 +6711,19 @@
       } 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
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
         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)
       });
@@ -6788,13 +6733,12 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
         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)
       });
@@ -6804,17 +6748,14 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     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)
       });
     },
     /**
@@ -6822,30 +6763,23 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     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 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
@@ -6856,12 +6790,10 @@
       } else {
         mod[facet] = [value];
       }
-
       return this.setQueryParameters({
         hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)
       });
     },
-
     /**
      * Adds a refinement on a hierarchical facet.
      * @param {string} facet the facet name
@@ -6869,7 +6801,7 @@
      * @return {SearchParameter} the new state
      * @throws Error if the facet is not defined or if the facet is refined
      */
-    addHierarchicalFacetRefinement: function(facet, path) {
+    addHierarchicalFacetRefinement: function addHierarchicalFacetRefinement(facet, path) {
       if (this.isHierarchicalFacetRefined(facet)) {
         throw new Error(facet + ' is already refined.');
       }
@@ -6882,14 +6814,13 @@
         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(facet) {
+    removeHierarchicalFacetRefinement: function removeHierarchicalFacetRefinement(facet) {
       if (!this.isHierarchicalFacetRefined(facet)) {
         return this;
       }
@@ -6903,40 +6834,39 @@
      * Switch the tag refinement
      * @method
      * @param {string} tag the tag to remove or add
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     toggleTagRefinement: function toggleTagRefinement(tag) {
       if (this.isTagRefined(tag)) {
         return this.removeTagRefinement(tag);
       }
-
       return this.addTagRefinement(tag);
     },
     /**
      * Test if the facet name is from one of the disjunctive facets
      * @method
      * @param {string} facet facet name to test
-     * @return {boolean}
+     * @return {boolean} true if facet is a disjunctive facet
      */
-    isDisjunctiveFacet: function(facet) {
+    isDisjunctiveFacet: function isDisjunctiveFacet(facet) {
       return this.disjunctiveFacets.indexOf(facet) > -1;
     },
     /**
      * Test if the facet name is from one of the hierarchical facets
      * @method
      * @param {string} facetName facet name to test
-     * @return {boolean}
+     * @return {boolean} true if facetName is a hierarchical facet
      */
-    isHierarchicalFacet: function(facetName) {
+    isHierarchicalFacet: function isHierarchicalFacet(facetName) {
       return this.getHierarchicalFacetByName(facetName) !== undefined;
     },
     /**
      * Test if the facet name is from one of the conjunctive/normal facets
      * @method
      * @param {string} facet facet name to test
-     * @return {boolean}
+     * @return {boolean} true if facet is a conjunctive facet
      */
-    isConjunctiveFacet: function(facet) {
+    isConjunctiveFacet: function isConjunctiveFacet(facet) {
       return this.facets.indexOf(facet) > -1;
     },
     /**
@@ -6977,7 +6907,7 @@
      * @param {string} facet name of the attribute for used for faceting
      * @param {string} value optional, will test if the value is used for refinement
      * if there is one, otherwise will test if the facet contains any refinement
-     * @return {boolean}
+     * @return {boolean} true if the facet is refined
      */
     isDisjunctiveFacetRefined: function isDisjunctiveFacetRefined(facet, value) {
       if (!this.isDisjunctiveFacet(facet)) {
@@ -6992,19 +6922,16 @@
      * @param {string} facet name of the attribute for used for faceting
      * @param {string} value optional, will test if the value is used for refinement
      * if there is one, otherwise will test if the facet contains any refinement
-     * @return {boolean}
+     * @return {boolean} true if the facet is refined
      */
     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;
     },
     /**
@@ -7019,29 +6946,21 @@
      */
     isNumericRefined: function isNumericRefined(attribute, operator, value) {
       if (value === undefined && operator === undefined) {
-        return !!this.numericRefinements[attribute];
+        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;
     },
     /**
      * Returns true if the tag refined, false otherwise
      * @method
      * @param {string} tag the tag to check
-     * @return {boolean}
+     * @return {boolean} true if tag is refined
      */
     isTagRefined: function isTagRefined(tag) {
       return this.tagRefinements.indexOf(tag) !== -1;
@@ -7051,83 +6970,63 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {string[]}
+     * @return {string[]} returns the list of refinements
      */
     getRefinedDisjunctiveFacets: function getRefinedDisjunctiveFacets() {
+      // eslint-disable-next-line consistent-this
       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) {
+      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());
+      }).concat(disjunctiveNumericRefinedFacets).concat(this.getRefinedHierarchicalFacets());
     },
     /**
      * Returns the list of all disjunctive facets refined
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {string[]}
+     * @return {string[]} returns the list of refinements
      */
     getRefinedHierarchicalFacets: function getRefinedHierarchicalFacets() {
+      // 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[]}
+     * @return {string[]} returns the list of facets that are not refined
      */
-    getUnrefinedDisjunctiveFacets: function() {
+    getUnrefinedDisjunctiveFacets: function getUnrefinedDisjunctiveFacets() {
       var refinedFacets = this.getRefinedDisjunctiveFacets();
-
-      return this.disjunctiveFacets.filter(function(f) {
+      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) {
+      Object.keys(this).forEach(function (paramName) {
         var paramValue = self[paramName];
         if (managedParameters.indexOf(paramName) === -1 && paramValue !== undefined) {
           queryParams[paramName] = paramValue;
         }
       });
-
       return queryParams;
     },
     /**
@@ -7142,11 +7041,8 @@
      */
     setQueryParameter: function setParameter(parameter, value) {
       if (this[parameter] === value) return this;
-
       var modification = {};
-
       modification[parameter] = value;
-
       return this.setQueryParameters(modification);
     },
     /**
@@ -7157,134 +7053,109 @@
      */
     setQueryParameters: function setQueryParameters(params) {
       if (!params) return this;
-
       var error = SearchParameters.validate(this, params);
-
       if (error) {
         throw error;
       }
 
+      // eslint-disable-next-line consistent-this
       var self = this;
       var nextWithNumbers = SearchParameters._parseNumbers(params);
-      var previousPlainObject = Object.keys(this).reduce(function(acc, key) {
+      var previousPlainObject = Object.keys(this).reduce(function (acc, key) {
         acc[key] = self[key];
         return acc;
       }, {});
-
-      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
-      );
-
+      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);
       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: function resetPage() {
       if (this.page === undefined) {
         return this;
       }
-
       return this.setPage(0);
     },
-
     /**
      * Helper function to get the hierarchicalFacet separator or the default one (`>`)
-     * @param  {object} hierarchicalFacet
+     * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.separator or `>` as default
      */
-    _getHierarchicalFacetSortBy: function(hierarchicalFacet) {
+    _getHierarchicalFacetSortBy: function _getHierarchicalFacetSortBy(hierarchicalFacet) {
       return hierarchicalFacet.sortBy || ['isRefined:desc', 'name:asc'];
     },
-
     /**
      * Helper function to get the hierarchicalFacet separator or the default one (`>`)
      * @private
-     * @param  {object} hierarchicalFacet
+     * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.separator or `>` as default
      */
-    _getHierarchicalFacetSeparator: function(hierarchicalFacet) {
+    _getHierarchicalFacetSeparator: function _getHierarchicalFacetSeparator(hierarchicalFacet) {
       return hierarchicalFacet.separator || ' > ';
     },
-
     /**
      * Helper function to get the hierarchicalFacet prefix path or null
      * @private
-     * @param  {object} hierarchicalFacet
+     * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.rootPath or null as default
      */
-    _getHierarchicalRootPath: function(hierarchicalFacet) {
+    _getHierarchicalRootPath: function _getHierarchicalRootPath(hierarchicalFacet) {
       return hierarchicalFacet.rootPath || null;
     },
-
     /**
      * Helper function to check if we show the parent level of the hierarchicalFacet
      * @private
-     * @param  {object} hierarchicalFacet
+     * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.showParentLevel or true as default
      */
-    _getHierarchicalShowParentLevel: function(hierarchicalFacet) {
+    _getHierarchicalShowParentLevel: function _getHierarchicalShowParentLevel(hierarchicalFacet) {
       if (typeof hierarchicalFacet.showParentLevel === 'boolean') {
         return hierarchicalFacet.showParentLevel;
       }
       return true;
     },
-
     /**
      * Helper function to get the hierarchicalFacet by it's name
-     * @param  {string} hierarchicalFacetName
+     * @param  {string} hierarchicalFacetName the hierarchicalFacet name
      * @return {object} a hierarchicalFacet
      */
-    getHierarchicalFacetByName: function(hierarchicalFacetName) {
-      return find$1(
-        this.hierarchicalFacets,
-        function(f) {
-          return f.name === hierarchicalFacetName;
-        }
-      );
+    getHierarchicalFacetByName: function getHierarchicalFacetByName(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(facetName) {
+    getHierarchicalFacetBreadcrumb: function getHierarchicalFacetBreadcrumb(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 path.map(function (part) {
         return part.trim();
       });
     },
-
-    toString: function() {
+    toString: function toString() {
       return JSON.stringify(this, null, 2);
     }
   };
@@ -7304,22 +7175,12 @@
     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;
       }
     }
@@ -7330,29 +7191,26 @@
    * @param {Array<object>} collection object with keys in attributes
    * @param {Array<string>} iteratees attributes
    * @param {Array<string>} orders asc | desc
+   * @return {Array<object>} sorted collection
    */
   function orderBy(collection, iteratees, orders) {
     if (!Array.isArray(collection)) {
       return [];
     }
-
     if (!Array.isArray(orders)) {
       orders = [];
     }
-
-    var result = collection.map(function(value, index) {
+    var result = collection.map(function (value, index) {
       return {
-        criteria: iteratees.map(function(iteratee) {
+        criteria: iteratees.map(function (iteratee) {
           return value[iteratee];
         }),
         index: index,
         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) {
@@ -7370,19 +7228,16 @@
       // 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 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);
   };
 
@@ -7391,7 +7246,6 @@
     if (!Array.isArray(array)) {
       return -1;
     }
-
     for (var i = 0; i < array.length; i++) {
       if (comparator(array[i])) {
         return i;
@@ -7407,43 +7261,33 @@
    * @return {array.<string[]>} array containing 2 elements : attributes, orders
    */
   var formatSort = function formatSort(sortBy, defaults) {
-    var defaultInstructions = (defaults || []).map(function(sort) {
+    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 out;
-        }
-
-        out[0].push(matchingDefault[0]);
-        out[1].push(matchingDefault[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;
+    }, [[], []]);
   };
 
   /**
    * Replaces a leading - with \-
    * @private
    * @param {any} value the facet value to replace
-   * @returns any
+   * @returns {any} the escaped facet value or the value if it was not a string
    */
   function escapeFacetValue$1(value) {
     if (typeof value !== 'string') return value;
-
     return String(value).replace(/^-/, '\\-');
   }
 
@@ -7451,14 +7295,12 @@
    * Replaces a leading \- with -
    * @private
    * @param {any} value the escaped facet value
-   * @returns any
+   * @returns {any} the unescaped facet value or the value if it was not a string
    */
   function unescapeFacetValue$1(value) {
     if (typeof value !== 'string') return value;
-
     return value.replace(/^\\-/, '-');
   }
-
   var escapeFacetValue_1 = {
     escapeFacetValue: escapeFacetValue$1,
     unescapeFacetValue: unescapeFacetValue$1
@@ -7469,87 +7311,50 @@
 
 
 
-
   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 rootExhaustive = hierarchicalFacetResult.every(function(facetResult) {
+      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
       });
     };
   }
-
-  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
            */
           var data = parent && Array.isArray(parent.data) ? parent.data : [];
-          parent = find$1(data, function(subtree) {
+          parent = find$1(data, function (subtree) {
             return subtree.isRefined;
           });
           level++;
@@ -7569,99 +7374,49 @@
         // 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;
     };
   }
 
-  function onlyMatchingTree(
-    facetValue,
-    parentPath,
-    currentRefinement,
-    hierarchicalSeparator,
-    hierarchicalRootPath,
-    hierarchicalShowParentLevel
-  ) {
+  // eslint-disable-next-line max-params
+  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
     };
@@ -7671,7 +7426,6 @@
   var unescapeFacetValue$3 = escapeFacetValue_1.unescapeFacetValue;
 
 
-
   /**
    * @typedef SearchResults.Facet
    * @type {object}
@@ -7714,18 +7468,17 @@
    */
 
   /**
-   * @param {string[]} attributes
+   * Turn an array of attributes in an object of attributes with their position in the array as value
+   * @param {string[]} attributes the list of attributes in the record
+   * @return {object} the list of attributes indexed by attribute name
    */
   function getIndices(attributes) {
     var indices = {};
-
-    attributes.forEach(function(val, idx) {
+    attributes.forEach(function (val, idx) {
       indices[val] = idx;
     });
-
     return indices;
   }
-
   function assignFacetStats(dest, facetStats, key) {
     if (facetStats && facetStats[key]) {
       dest.stats = facetStats[key];
@@ -7739,22 +7492,18 @@
    */
 
   /**
-   * @param {HierarchicalFacet[]} hierarchicalFacets
-   * @param {string} hierarchicalAttributeName
+   * @param {HierarchicalFacet[]} hierarchicalFacets All hierarchical facets
+   * @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
-    ) {
+  function findMatchingHierarchicalFacetFromAttributeName(hierarchicalFacets, hierarchicalAttributeName) {
+    return find$1(hierarchicalFacets, function facetKeyMatchesAttribute(hierarchicalFacet) {
       var facetNames = hierarchicalFacet.attributes || [];
       return facetNames.indexOf(hierarchicalAttributeName) > -1;
     });
   }
 
-  /*eslint-disable */
+  // eslint-disable-next-line valid-jsdoc
   /**
    * Constructor for SearchResults
    * @class
@@ -7885,21 +7634,20 @@
      "index": "bestbuy"
   }
    **/
-  /*eslint-enable */
   function SearchResults(state, results, options) {
     var mainSubResponse = results[0];
-
     this._rawResults = results;
 
+    // eslint-disable-next-line consistent-this
     var self = this;
 
     // https://www.algolia.com/doc/api-reference/api-methods/search/#response
-    Object.keys(mainSubResponse).forEach(function(key) {
+    Object.keys(mainSubResponse).forEach(function (key) {
       self[key] = mainSubResponse[key];
     });
 
     // Make every key of the result options reachable from the instance
-    Object.keys(options || {}).forEach(function(key) {
+    Object.keys(options || {}).forEach(function (key) {
       self[key] = options[key];
     });
 
@@ -7921,8 +7669,8 @@
      * all the records that match the search parameters. Each record is
      * augmented with a new attribute `_highlightResult`
      * which is an object keyed by attribute and with the following properties:
-     *  - `value` : the value of the facet highlighted (html)
-     *  - `matchLevel`: full, partial or none depending on how the query terms match
+     * - `value` : the value of the facet highlighted (html)
+     * - `matchLevel`: `full`, `partial` or `none`, depending on how the query terms match
      * @name hits
      * @member {object[]}
      * @memberof SearchResults
@@ -8043,10 +7791,8 @@
      * @memberof SearchResults
      * @instance
      */
-    this.processingTimeMS = results.reduce(function(sum, result) {
-      return result.processingTimeMS === undefined
-        ? sum
-        : sum + result.processingTimeMS;
+    this.processingTimeMS = results.reduce(function (sum, result) {
+      return result.processingTimeMS === undefined ? sum : sum + result.processingTimeMS;
     }, 0);
 
     /**
@@ -8066,9 +7812,7 @@
      * @member {SearchResults.Facet[]}
      */
     this.facets = [];
-
     var disjunctiveFacets = state.getRefinedDisjunctiveFacets();
-
     var facetsIndices = getIndices(state.facets);
     var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);
     var nextDisjunctiveResult = 1;
@@ -8077,20 +7821,14 @@
     // we get the facets information from the first, general, response.
 
     var mainFacets = mainSubResponse.facets || {};
-
-    Object.keys(mainFacets).forEach(function(facetKey) {
+    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
         var facetIndex = hierarchicalFacet.attributes.indexOf(facetKey);
-        var idxAttributeName = findIndex$1(state.hierarchicalFacets, function(f) {
+        var idxAttributeName = findIndex$1(state.hierarchicalFacets, function (f) {
           return f.name === hierarchicalFacet.name;
         });
         self.hierarchicalFacets[idxAttributeName][facetIndex] = {
@@ -8102,7 +7840,6 @@
         var isFacetDisjunctive = state.disjunctiveFacets.indexOf(facetKey) !== -1;
         var isFacetConjunctive = state.facets.indexOf(facetKey) !== -1;
         var position;
-
         if (isFacetDisjunctive) {
           position = disjunctiveFacetsIndices[facetKey];
           self.disjunctiveFacets[position] = {
@@ -8128,22 +7865,20 @@
     this.hierarchicalFacets = compact(this.hierarchicalFacets);
 
     // aggregate the refined disjunctive facets
-    disjunctiveFacets.forEach(function(disjunctiveFacet) {
+    disjunctiveFacets.forEach(function (disjunctiveFacet) {
       var result = results[nextDisjunctiveResult];
       var facets = result && result.facets ? result.facets : {};
       var hierarchicalFacet = state.getHierarchicalFacetByName(disjunctiveFacet);
 
       // There should be only item in facets.
-      Object.keys(facets).forEach(function(dfacet) {
+      Object.keys(facets).forEach(function (dfacet) {
         var facetResults = facets[dfacet];
-
         var position;
-
         if (hierarchicalFacet) {
-          position = findIndex$1(state.hierarchicalFacets, function(f) {
+          position = findIndex$1(state.hierarchicalFacets, function (f) {
             return f.name === hierarchicalFacet.name;
           });
-          var attributeIndex = findIndex$1(self.hierarchicalFacets[position], function(f) {
+          var attributeIndex = findIndex$1(self.hierarchicalFacets[position], function (f) {
             return f.attribute === dfacet;
           });
 
@@ -8151,29 +7886,20 @@
           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] || {};
-
           self.disjunctiveFacets[position] = {
             name: dfacet,
             data: defaultsPure({}, facetResults, dataFromMainRequest),
             exhaustive: result.exhaustiveFacetsCount
           };
           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;
               }
             });
@@ -8184,28 +7910,23 @@
     });
 
     // if we have some parent level values for hierarchical facets, merge them
-    state.getRefinedHierarchicalFacets().forEach(function(refinedFacet) {
+    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) {
         return;
       }
-
-      results.slice(nextDisjunctiveResult).forEach(function(result) {
-        var facets = result && result.facets
-          ? result.facets
-          : {};
-
-        Object.keys(facets).forEach(function(dfacet) {
+      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) {
+          var position = findIndex$1(state.hierarchicalFacets, function (f) {
             return f.name === hierarchicalFacet.name;
           });
-          var attributeIndex = findIndex$1(self.hierarchicalFacets[position], function(f) {
+          var attributeIndex = findIndex$1(self.hierarchicalFacets[position], function (f) {
             return f.attribute === dfacet;
           });
 
@@ -8223,35 +7944,29 @@
           //   | 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];
           }
-
-          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++;
       });
     });
 
     // add the excludes
-    Object.keys(state.facetsExcludes).forEach(function(facetName) {
+    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
       };
-      excludes.forEach(function(facetValue) {
-        self.facets[position] = self.facets[position] || {name: facetName};
+      excludes.forEach(function (facetValue) {
+        self.facets[position] = self.facets[position] || {
+          name: facetName
+        };
         self.facets[position].data = self.facets[position].data || {};
         self.facets[position].data[facetValue] = 0;
       });
@@ -8270,7 +7985,6 @@
      * @type {Array}
      */
     this.disjunctiveFacets = compact(this.disjunctiveFacets);
-
     this._state = state;
   }
 
@@ -8280,14 +7994,11 @@
    * @param {string} name name of the faceted attribute
    * @return {SearchResults.Facet} the facet object
    */
-  SearchResults.prototype.getFacetByName = function(name) {
+  SearchResults.prototype.getFacetByName = function (name) {
     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);
   };
 
   /**
@@ -8301,12 +8012,10 @@
     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) {
+      return Object.keys(facet.data).map(function (name) {
         var value = escapeFacetValue$3(name);
         return {
           name: name,
@@ -8319,8 +8028,7 @@
     } else if (results._state.isDisjunctiveFacet(attribute)) {
       var disjunctiveFacet = find$1(results.disjunctiveFacets, predicate);
       if (!disjunctiveFacet) return [];
-
-      return Object.keys(disjunctiveFacet.data).map(function(name) {
+      return Object.keys(disjunctiveFacet.data).map(function (name) {
         var value = escapeFacetValue$3(name);
         return {
           name: name,
@@ -8332,29 +8040,31 @@
     } else if (results._state.isHierarchicalFacet(attribute)) {
       var hierarchicalFacetValues = find$1(results.hierarchicalFacets, predicate);
       if (!hierarchicalFacetValues) return hierarchicalFacetValues;
-
       var hierarchicalFacet = results._state.getHierarchicalFacetByName(attribute);
-      var currentRefinementSplit = unescapeFacetValue$3(
-        results._state.getHierarchicalRefinement(attribute)[0] || ''
-      ).split(results._state._getHierarchicalFacetSeparator(hierarchicalFacet));
+      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, '');
+      }
+      var currentRefinementSplit = currentRefinement.split(separator);
       currentRefinementSplit.unshift(attribute);
-
       setIsRefined(hierarchicalFacetValues, currentRefinementSplit, 0);
-
       return hierarchicalFacetValues;
     }
+    return undefined;
   }
 
   /**
    * Set the isRefined of a hierarchical facet result based on the current state.
    * @param {SearchResults.HierarchicalFacet} item Hierarchical facet to fix
-   * @param {string[]} currentRefinementSplit array of parts of the current hierarchical refinement
+   * @param {string[]} currentRefinement array of parts of the current hierarchical refinement
    * @param {number} depth recursion depth in the currentRefinement
+   * @return {undefined} function mutates the item
    */
   function setIsRefined(item, currentRefinement, depth) {
     item.isRefined = item.name === currentRefinement[depth];
     if (item.data) {
-      item.data.forEach(function(child) {
+      item.data.forEach(function (child) {
         setIsRefined(child, currentRefinement, depth + 1);
       });
     }
@@ -8363,32 +8073,30 @@
   /**
    * Sort nodes of a hierarchical or disjunctive facet results
    * @private
-   * @param {function} sortFn
+   * @param {function} sortFn sort function to apply
    * @param {HierarchicalFacet|Array} node node upon which we want to apply the sort
    * @param {string[]} names attribute names
    * @param {number} [level=0] current index in the names array
+   * @return {HierarchicalFacet|Array} sorted node
    */
   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) {
+    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);
   }
@@ -8404,23 +8112,21 @@
    * Sorts facet arrays via their facet ordering
    * @param {Array} facetValues the values
    * @param {FacetOrdering} facetOrdering the ordering
-   * @returns {Array}
+   * @returns {Array} the sorted facet values
    */
   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:
      * ['one', 'two'] -> { one: 0, two: 1 }
      */
-    var reverseOrder = order.reduce(function(acc, name, i) {
+    var reverseOrder = order.reduce(function (acc, name, i) {
       acc[name] = i;
       return acc;
     }, {});
-
-    facetValues.forEach(function(item) {
+    facetValues.forEach(function (item) {
       // hierarchical facets get sorted using their raw name
       var name = item.path || item.name;
       if (reverseOrder[name] !== undefined) {
@@ -8429,11 +8135,9 @@
         remainingFacets.push(item);
       }
     });
-
-    orderedFacets = orderedFacets.filter(function(facet) {
+    orderedFacets = orderedFacets.filter(function (facet) {
       return facet;
     });
-
     var sortRemainingBy = facetOrdering.sortRemainingBy;
     var ordering;
     if (sortRemainingBy === 'hidden') {
@@ -8443,24 +8147,16 @@
     } else {
       ordering = [['count'], ['desc']];
     }
-
-    return orderedFacets.concat(
-      orderBy_1(remainingFacets, ordering[0], ordering[1])
-    );
+    return orderedFacets.concat(orderBy_1(remainingFacets, ordering[0], ordering[1]));
   }
 
   /**
    * @param {SearchResults} results the search results class
    * @param {string} attribute the attribute to retrieve ordering of
-   * @returns {FacetOrdering=}
+   * @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];
   }
 
   /**
@@ -8511,12 +8207,11 @@
    *   });
    * });
    */
-  SearchResults.prototype.getFacetValues = function(attribute, opts) {
+  SearchResults.prototype.getFacetValues = function (attribute, opts) {
     var facetValues = extractNormalizedFacetValues(this, attribute);
     if (!facetValues) {
       return undefined;
     }
-
     var options = defaultsPure({}, opts, {
       sortBy: SearchResults.DEFAULT_SORT,
       // if no sortBy is given, attempt to sort based on facetOrdering
@@ -8524,6 +8219,7 @@
       facetOrdering: !(opts && opts.sortBy)
     });
 
+    // eslint-disable-next-line consistent-this
     var results = this;
     var attributes;
     if (Array.isArray(facetValues)) {
@@ -8532,25 +8228,20 @@
       var config = results._state.getHierarchicalFacetByName(facetValues.name);
       attributes = config.attributes;
     }
-
-    return recSort(function(data, facetName) {
+    return recSort(function (data, facetName) {
       if (options.facetOrdering) {
         var facetOrdering = getFacetOrdering(results, facetName);
-        if (Boolean(facetOrdering)) {
+        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);
       }
-      throw new Error(
-        'options.sortBy is optional but if defined it must be ' +
-          'either an array of string (predicates) or a sorting function'
-      );
+      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);
   };
 
@@ -8560,13 +8251,12 @@
    * @param {string} attribute name of the faceted attribute
    * @return {object} The stats of the facet
    */
-  SearchResults.prototype.getFacetStats = function(attribute) {
+  SearchResults.prototype.getFacetStats = function (attribute) {
     if (this._state.isConjunctiveFacet(attribute)) {
       return getFacetStatsIfAvailable(this.facets, attribute);
     } else if (this._state.isDisjunctiveFacet(attribute)) {
       return getFacetStatsIfAvailable(this.disjunctiveFacets, attribute);
     }
-
     return undefined;
   };
 
@@ -8577,10 +8267,11 @@
 
   /**
    * @param {FacetListItem[]} facetList (has more items, but enough for here)
-   * @param {string} facetName
+   * @param {string} facetName The attribute to look for
+   * @return {object|undefined} The stats of the facet
    */
   function getFacetStatsIfAvailable(facetList, facetName) {
-    var data = find$1(facetList, function(facet) {
+    var data = find$1(facetList, function (facet) {
       return facet.name === facetName;
     });
     return data && data.stats;
@@ -8598,40 +8289,35 @@
    *
    * @return {Array.<Refinement>} all the refinements
    */
-  SearchResults.prototype.getRefinements = function() {
+  SearchResults.prototype.getRefinements = function () {
     var state = this._state;
+    // eslint-disable-next-line consistent-this
     var results = this;
     var res = [];
-
-    Object.keys(state.facetsRefinements).forEach(function(attributeName) {
-      state.facetsRefinements[attributeName].forEach(function(name) {
+    Object.keys(state.facetsRefinements).forEach(function (attributeName) {
+      state.facetsRefinements[attributeName].forEach(function (name) {
         res.push(getRefinement$1(state, 'facet', attributeName, name, results.facets));
       });
     });
-
-    Object.keys(state.facetsExcludes).forEach(function(attributeName) {
-      state.facetsExcludes[attributeName].forEach(function(name) {
+    Object.keys(state.facetsExcludes).forEach(function (attributeName) {
+      state.facetsExcludes[attributeName].forEach(function (name) {
         res.push(getRefinement$1(state, 'exclude', attributeName, name, results.facets));
       });
     });
-
-    Object.keys(state.disjunctiveFacetsRefinements).forEach(function(attributeName) {
-      state.disjunctiveFacetsRefinements[attributeName].forEach(function(name) {
+    Object.keys(state.disjunctiveFacetsRefinements).forEach(function (attributeName) {
+      state.disjunctiveFacetsRefinements[attributeName].forEach(function (name) {
         res.push(getRefinement$1(state, 'disjunctive', attributeName, name, results.disjunctiveFacets));
       });
     });
-
-    Object.keys(state.hierarchicalFacetsRefinements).forEach(function(attributeName) {
-      state.hierarchicalFacetsRefinements[attributeName].forEach(function(name) {
+    Object.keys(state.hierarchicalFacetsRefinements).forEach(function (attributeName) {
+      state.hierarchicalFacetsRefinements[attributeName].forEach(function (name) {
         res.push(getHierarchicalRefinement(state, attributeName, name, results.hierarchicalFacets));
       });
     });
-
-
-    Object.keys(state.numericRefinements).forEach(function(attributeName) {
+    Object.keys(state.numericRefinements).forEach(function (attributeName) {
       var operators = state.numericRefinements[attributeName];
-      Object.keys(operators).forEach(function(operator) {
-        operators[operator].forEach(function(value) {
+      Object.keys(operators).forEach(function (operator) {
+        operators[operator].forEach(function (value) {
           res.push({
             type: 'numeric',
             attributeName: attributeName,
@@ -8642,11 +8328,13 @@
         });
       });
     });
-
-    state.tagRefinements.forEach(function(name) {
-      res.push({type: 'tag', attributeName: '_tags', name: name});
+    state.tagRefinements.forEach(function (name) {
+      res.push({
+        type: 'tag',
+        attributeName: '_tags',
+        name: name
+      });
     });
-
     return res;
   };
 
@@ -8658,19 +8346,19 @@
    */
 
   /**
-   * @param {*} state
-   * @param {*} type
-   * @param {string} attributeName
-   * @param {*} name
-   * @param {Facet[]} resultsFacets
+   * @param {SearchParameters} state the current state
+   * @param {string} type the type of the refinement
+   * @param {string} attributeName The attribute of the facet
+   * @param {*} name The name of the facet
+   * @param {Facet[]} resultsFacets facets from the results
+   * @return {Refinement} the refinement
    */
   function getRefinement$1(state, type, attributeName, name, resultsFacets) {
-    var facet = find$1(resultsFacets, function(f) {
+    var facet = find$1(resultsFacets, function (f) {
       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,
@@ -8681,31 +8369,28 @@
   }
 
   /**
-   * @param {*} state
-   * @param {string} attributeName
-   * @param {*} name
-   * @param {Facet[]} resultsFacets
+   * @param {SearchParameters} state the current state
+   * @param {string} attributeName the attribute of the hierarchical facet
+   * @param {string} name the name of the facet
+   * @param {Facet[]} resultsFacets facets from the results
+   * @return {HierarchicalFacet} the hierarchical facet
    */
   function getHierarchicalRefinement(state, attributeName, name, resultsFacets) {
     var facetDeclaration = state.getHierarchicalFacetByName(attributeName);
     var separator = state._getHierarchicalFacetSeparator(facetDeclaration);
     var split = name.split(separator);
-    var rootFacet = find$1(resultsFacets, function(facet) {
+    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 facet = split.reduce(function (intermediateFacet, 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,
@@ -8714,7 +8399,6 @@
       exhaustive: exhaustive
     };
   }
-
   var SearchResults_1 = SearchResults;
 
   // Copyright Joyent, Inc. and other Node contributors.
@@ -9030,7 +8714,6 @@
       }
     });
   }
-
   var inherits_1 = inherits;
 
   /**
@@ -9042,13 +8725,14 @@
    *  - result: when the response is retrieved from Algolia and is processed.
    *    This event contains a {@link SearchResults} object and the
    *    {@link SearchParameters} corresponding to this answer.
+   * @param {AlgoliaSearchHelper} mainHelper the main helper
+   * @param {function} fn the function to create the derived state
    */
   function DerivedHelper(mainHelper, fn) {
     this.main = mainHelper;
     this.fn = fn;
     this.lastResults = null;
   }
-
   inherits_1(DerivedHelper, events);
 
   /**
@@ -9056,33 +8740,30 @@
    * @return {undefined}
    * @throws Error if the derived helper is already detached
    */
-  DerivedHelper.prototype.detach = function() {
+  DerivedHelper.prototype.detach = function () {
     this.removeAllListeners();
     this.main.detachDerivedHelper(this);
   };
-
-  DerivedHelper.prototype.getModifiedState = function(parameters) {
+  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
      * with the Algolia client.
      * @private
+     * @param  {string} index The name of the index
+     * @param  {SearchParameters} state The state from which to get the queries
      * @return {object[]} The queries
      */
     _getQueries: function getQueries(index, state) {
@@ -9095,7 +8776,7 @@
       });
 
       // One for each disjunctive facets
-      state.getRefinedDisjunctiveFacets().forEach(function(refinedFacet) {
+      state.getRefinedDisjunctiveFacets().forEach(function (refinedFacet) {
         queries.push({
           indexName: index,
           params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet)
@@ -9103,7 +8784,7 @@
       });
 
       // More to get the parent levels of the hierarchical facets when refined
-      state.getRefinedHierarchicalFacets().forEach(function(refinedFacet) {
+      state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {
         var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);
         var currentRefinement = state.getHierarchicalRefinement(refinedFacet);
         var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
@@ -9112,75 +8793,58 @@
         // we want to get all parent values
         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)
-              });
-            }
-          , []);
-
-          filtersMap.forEach(function(filter, level) {
-            var params = requestBuilder._getDisjunctiveFacetSearchParams(
-              state,
-              filter.attribute,
-              level === 0
-            );
+          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);
 
             // Keep facet filters unrelated to current hierarchical attributes
             function hasHierarchicalFacetFilter(value) {
-              return hierarchicalFacet.attributes.some(function(attribute) {
+              return hierarchicalFacet.attributes.some(function (attribute) {
                 return attribute === value.split(':')[0];
               });
             }
-
-            var filteredFacetFilters = (params.facetFilters || []).reduce(function(acc, facetFilter) {
+            var filteredFacetFilters = (params.facetFilters || []).reduce(function (acc, facetFilter) {
               if (Array.isArray(facetFilter)) {
-                var filtered = facetFilter.filter(function(filterValue) {
+                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;
             }, []);
-
             var parent = filtersMap[level - 1];
             if (level > 0) {
               params.facetFilters = filteredFacetFilters.concat(parent.attribute + ':' + parent.value);
             } else {
               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
-     * @return {object.<string, any>}
+     * @param  {SearchParameters} state The state from which to get the queries
+     * @return {object.<string, any>} The search parameters for hits
      */
-    _getHitsSearchParams: function(state) {
-      var facets = state.facets
-        .concat(state.disjunctiveFacets)
-        .concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state));
-
-
+    _getHitsSearchParams: function _getHitsSearchParams(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);
@@ -9188,26 +8852,23 @@
         facets: facets.indexOf('*') > -1 ? ['*'] : facets,
         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
+     * @param  {SearchParameters} state The state from which to get the queries
      * @param  {string} facet the associated facet name
      * @param  {boolean} hierarchicalRootLevel ?? FIXME
-     * @return {object}
+     * @return {object} The search parameters for a disjunctive facet
      */
-    _getDisjunctiveFacetSearchParams: function(state, facet, hierarchicalRootLevel) {
+    _getDisjunctiveFacetSearchParams: function _getDisjunctiveFacetSearchParams(state, facet, hierarchicalRootLevel) {
       var facetFilters = requestBuilder._getFacetFilters(state, facet, hierarchicalRootLevel);
       var numericFilters = requestBuilder._getNumericFilters(state, facet);
       var tagFilters = requestBuilder._getTagFilters(state);
@@ -9217,55 +8878,43 @@
         analytics: 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
+     * @param {SearchParameters} state the state from which to get the filters
      * @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(state, facetName) {
+    _getNumericFilters: function _getNumericFilters(state, facetName) {
       if (state.numericFilters) {
         return state.numericFilters;
       }
-
       var numericFilters = [];
-
-      Object.keys(state.numericRefinements).forEach(function(attribute) {
+      Object.keys(state.numericRefinements).forEach(function (attribute) {
         var operators = state.numericRefinements[attribute] || {};
-        Object.keys(operators).forEach(function(operator) {
+        Object.keys(operators).forEach(function (operator) {
           var values = operators[operator] || [];
           if (facetName !== attribute) {
-            values.forEach(function(value) {
+            values.forEach(function (value) {
               if (Array.isArray(value)) {
-                var vs = value.map(function(v) {
+                var vs = value.map(function (v) {
                   return attribute + operator + v;
                 });
                 numericFilters.push(vs);
@@ -9276,74 +8925,64 @@
           }
         });
       });
-
       return numericFilters;
     },
-
     /**
-     * Return the tags filters depending
+     * Return the tags filters depending on which format is used, either tagFilters or tagRefinements
      * @private
-     * @return {string}
+     * @param {SearchParameters} state the state from which to get the filters
+     * @return {string} Tag filters in a single string
      */
-    _getTagFilters: function(state) {
+    _getTagFilters: function _getTagFilters(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.
      * @private
+     * @param  {SearchParameters} state The state from which to get the queries
      * @param  {string} [facet] if set, the current disjunctive facet
-     * @return {array.<string>}
+     * @param  {boolean} [hierarchicalRootLevel] ?? FIXME
+     * @return {array.<string>} The facet filters in the algolia format
      */
-    _getFacetFilters: function(state, facet, hierarchicalRootLevel) {
+    _getFacetFilters: function _getFacetFilters(state, facet, hierarchicalRootLevel) {
       var facetFilters = [];
-
       var facetsRefinements = state.facetsRefinements || {};
-      Object.keys(facetsRefinements).forEach(function(facetName) {
+      Object.keys(facetsRefinements).forEach(function (facetName) {
         var facetValues = facetsRefinements[facetName] || [];
-        facetValues.forEach(function(facetValue) {
+        facetValues.forEach(function (facetValue) {
           facetFilters.push(facetName + ':' + facetValue);
         });
       });
-
       var facetsExcludes = state.facetsExcludes || {};
-      Object.keys(facetsExcludes).forEach(function(facetName) {
+      Object.keys(facetsExcludes).forEach(function (facetName) {
         var facetValues = facetsExcludes[facetName] || [];
-        facetValues.forEach(function(facetValue) {
+        facetValues.forEach(function (facetValue) {
           facetFilters.push(facetName + ':-' + facetValue);
         });
       });
-
       var disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements || {};
-      Object.keys(disjunctiveFacetsRefinements).forEach(function(facetName) {
+      Object.keys(disjunctiveFacetsRefinements).forEach(function (facetName) {
         var facetValues = disjunctiveFacetsRefinements[facetName] || [];
         if (facetName === facet || !facetValues || facetValues.length === 0) {
           return;
         }
         var orFilters = [];
-
-        facetValues.forEach(function(facetValue) {
+        facetValues.forEach(function (facetValue) {
           orFilters.push(facetName + ':' + facetValue);
         });
-
         facetFilters.push(orFilters);
       });
-
       var hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements || {};
-      Object.keys(hierarchicalFacetsRefinements).forEach(function(facetName) {
+      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);
@@ -9354,11 +8993,9 @@
         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));
@@ -9366,56 +9003,45 @@
             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(state) {
+    _getHitsHierarchicalFacetsAttributes: function _getHitsHierarchicalFacetsAttributes(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(state, hierarchicalFacet, rootLevel) {
+    _getDisjunctiveHierarchicalFacetAttribute: function _getDisjunctiveHierarchicalFacetAttribute(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] || '';
       // if refinement is 'beers > IPA > Flying dog',
       // then we want `facets: ['beers > IPA']` as disjunctive facet (parent level values)
@@ -9423,11 +9049,8 @@
       var parentLevel = hierarchicalRefinement.split(separator).length - 1;
       return hierarchicalFacet.attributes.slice(0, parentLevel + 1);
     },
-
-    getSearchForFacetQuery: function(facetName, query, maxFacetHits, state) {
-      var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ?
-        state.clearRefinements(facetName) :
-        state;
+    getSearchForFacetQuery: function getSearchForFacetQuery(facetName, query, maxFacetHits, state) {
+      var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ? state.clearRefinements(facetName) : state;
       var searchForFacetSearchParameters = {
         facetQuery: query,
         facetName: facetName
@@ -9435,17 +9058,12 @@
       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.2';
+  var version = '3.13.3';
 
   var escapeFacetValue$4 = escapeFacetValue_1.escapeFacetValue;
 
@@ -9556,7 +9174,6 @@
     if (typeof client.addAlgoliaAgent === 'function') {
       client.addAlgoliaAgent('JS Helper (' + version + ')');
     }
-
     this.setClient(client);
     var opts = options || {};
     opts.index = index;
@@ -9567,7 +9184,6 @@
     this.derivedHelpers = [];
     this._currentNbQueries = 0;
   }
-
   inherits_1(AlgoliaSearchHelper, events);
 
   /**
@@ -9575,19 +9191,22 @@
    * method is called, it triggers a `search` event. The results will
    * be available through the `result` event. If an error occurs, an
    * `error` will be fired instead.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires search
    * @fires result
    * @fires error
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.search = function() {
-    this._search({onlyWithDerivedHelpers: false});
+  AlgoliaSearchHelper.prototype.search = function () {
+    this._search({
+      onlyWithDerivedHelpers: false
+    });
     return this;
   };
-
-  AlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function() {
-    this._search({onlyWithDerivedHelpers: true});
+  AlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function () {
+    this._search({
+      onlyWithDerivedHelpers: true
+    });
     return this;
   };
 
@@ -9596,7 +9215,7 @@
    * for the hits
    * @return {object} Query Parameters
    */
-  AlgoliaSearchHelper.prototype.getQuery = function() {
+  AlgoliaSearchHelper.prototype.getQuery = function () {
     var state = this.state;
     return requestBuilder_1._getHitsSearchParams(state);
   };
@@ -9608,7 +9227,7 @@
    * same as a search call before calling searchOnce.
    * @param {object} options can contain all the parameters that can be set to SearchParameters
    * plus the index
-   * @param {function} [callback] optional callback executed when the response from the
+   * @param {function} [cb] optional callback executed when the response from the
    * server is back.
    * @return {promise|undefined} if a callback is passed the method returns undefined
    * otherwise it returns a promise containing an object with two keys :
@@ -9637,41 +9256,32 @@
    *   // }
    * }
    */
-  AlgoliaSearchHelper.prototype.searchOnce = function(options, cb) {
+  AlgoliaSearchHelper.prototype.searchOnce = function (options, cb) {
     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
     });
-
     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) {
+    return this.client.search(queries).then(function (content) {
       self._currentNbQueries--;
       if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
       return {
@@ -9679,14 +9289,14 @@
         state: tempState,
         _originalResponse: content
       };
-    }, function(e) {
+    }, function (e) {
       self._currentNbQueries--;
       if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
       throw e;
     });
   };
 
-   /**
+  /**
    * Start the search for answers with the parameters set in the state.
    * This method returns a promise.
    * @param {Object} options - the options for answers API call
@@ -9697,7 +9307,8 @@
    * @return {promise} the answer results
    * @deprecated answers is deprecated and will be replaced with new initiatives
    */
-  AlgoliaSearchHelper.prototype.findAnswers = function(options) {
+  AlgoliaSearchHelper.prototype.findAnswers = function (options) {
+    // eslint-disable-next-line no-console
     console.warn('[algoliasearch-helper] answers is no longer supported');
     var state = this.state;
     var derivedHelper = this.derivedHelpers[0];
@@ -9705,21 +9316,12 @@
       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' // FIXME remove this line once the engine is fixed.
-        ])
-      }
-    );
-
+    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);
@@ -9765,75 +9367,56 @@
    * 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);
-
     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) {
+      content.facetHits.forEach(function (f) {
         f.escapedValue = escapeFacetValue$4(f.value);
-        f.isRefined = isDisjunctive
-          ? state.isDisjunctiveFacetRefined(facet, f.escapedValue)
-          : state.isFacetRefined(facet, f.escapedValue);
+        f.isRefined = isDisjunctive ? state.isDisjunctiveFacetRefined(facet, f.escapedValue) : state.isFacetRefined(facet, f.escapedValue);
       });
-
       return content;
-    }, function(e) {
+    }, function (e) {
       self._currentNbQueries--;
       if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
       throw e;
@@ -9845,16 +9428,15 @@
    *
    * This method resets the current page to 0.
    * @param  {string} q the user query
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.setQuery = function(q) {
+  AlgoliaSearchHelper.prototype.setQuery = function (q) {
     this._change({
       state: this.state.resetPage().setQuery(q),
       isPageReset: true
     });
-
     return this;
   };
 
@@ -9866,7 +9448,7 @@
    *
    * This method resets the current page to 0.
    * @param {string} [name] optional name of the facet / attribute on which we want to remove all refinements
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    * @example
@@ -9881,12 +9463,11 @@
    *   return type === 'exclude' && attribute === 'category';
    * }).search();
    */
-  AlgoliaSearchHelper.prototype.clearRefinements = function(name) {
+  AlgoliaSearchHelper.prototype.clearRefinements = function (name) {
     this._change({
       state: this.state.resetPage().clearRefinements(name),
       isPageReset: true
     });
-
     return this;
   };
 
@@ -9894,16 +9475,15 @@
    * Remove all the tag filters.
    *
    * This method resets the current page to 0.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.clearTags = function() {
+  AlgoliaSearchHelper.prototype.clearTags = function () {
     this._change({
       state: this.state.resetPage().clearTags(),
       isPageReset: true
     });
-
     return this;
   };
 
@@ -9914,23 +9494,23 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value (will be converted to string)
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @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
     });
-
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addDisjunctiveFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.addDisjunctiveRefine = function() {
+  AlgoliaSearchHelper.prototype.addDisjunctiveRefine = function () {
     return this.addDisjunctiveFacetRefinement.apply(this, arguments);
   };
 
@@ -9942,17 +9522,16 @@
    * This method resets the current page to 0.
    * @param {string} facet the facet name
    * @param {string} path the hierarchical facet path
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @throws Error if the facet is not defined or if the facet is refined
    * @chainable
    * @fires change
    */
-  AlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function (facet, path) {
     this._change({
-      state: this.state.resetPage().addHierarchicalFacetRefinement(facet, value),
+      state: this.state.resetPage().addHierarchicalFacetRefinement(facet, path),
       isPageReset: true
     });
-
     return this;
   };
 
@@ -9964,16 +9543,15 @@
    * @param  {string} attribute the attribute on which the numeric filter applies
    * @param  {string} operator the operator of the filter
    * @param  {number} value the value of the filter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @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
     });
-
     return this;
   };
 
@@ -9984,27 +9562,26 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value (will be converted to string)
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.addFacetRefinement = function (facet, value) {
     this._change({
       state: this.state.resetPage().addFacetRefinement(facet, value),
       isPageReset: true
     });
-
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.addRefine = function() {
+  AlgoliaSearchHelper.prototype.addRefine = function () {
     return this.addFacetRefinement.apply(this, arguments);
   };
 
-
   /**
    * Adds a an exclusion filter to a faceted attribute with the `value` provided. If the
    * filter is already set, it doesn't change the filters.
@@ -10012,23 +9589,23 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value (will be converted to string)
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addFacetExclusion = function(facet, value) {
+  AlgoliaSearchHelper.prototype.addFacetExclusion = function (facet, value) {
     this._change({
       state: this.state.resetPage().addExcludeRefinement(facet, value),
       isPageReset: true
     });
-
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetExclusion}
    */
-  AlgoliaSearchHelper.prototype.addExclude = function() {
+  AlgoliaSearchHelper.prototype.addExclude = function () {
     return this.addFacetExclusion.apply(this, arguments);
   };
 
@@ -10038,16 +9615,15 @@
    *
    * This method resets the current page to 0.
    * @param {string} tag the tag to add to the filter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addTag = function(tag) {
+  AlgoliaSearchHelper.prototype.addTag = function (tag) {
     this._change({
       state: this.state.resetPage().addTagRefinement(tag),
       isPageReset: true
     });
-
     return this;
   };
 
@@ -10065,16 +9641,15 @@
    * @param  {string} attribute the attribute on which the numeric filter applies
    * @param  {string} [operator] the operator of the filter
    * @param  {number} [value] the value of the filter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @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
     });
-
     return this;
   };
 
@@ -10088,40 +9663,39 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} [value] the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @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
     });
-
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeDisjunctiveFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function() {
+  AlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function () {
     return this.removeDisjunctiveFacetRefinement.apply(this, arguments);
   };
 
   /**
    * Removes the refinement set on a hierarchical facet.
    * @param {string} facet the facet name
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @throws Error if the facet is not defined or if the facet is not refined
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function(facet) {
+  AlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function (facet) {
     this._change({
       state: this.state.resetPage().removeHierarchicalFacetRefinement(facet),
       isPageReset: true
     });
-
     return this;
   };
 
@@ -10135,23 +9709,23 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} [value] the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.removeFacetRefinement = function (facet, value) {
     this._change({
       state: this.state.resetPage().removeFacetRefinement(facet, value),
       isPageReset: true
     });
-
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.removeRefine = function() {
+  AlgoliaSearchHelper.prototype.removeRefine = function () {
     return this.removeFacetRefinement.apply(this, arguments);
   };
 
@@ -10165,23 +9739,23 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} [value] the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeFacetExclusion = function(facet, value) {
+  AlgoliaSearchHelper.prototype.removeFacetExclusion = function (facet, value) {
     this._change({
       state: this.state.resetPage().removeExcludeRefinement(facet, value),
       isPageReset: true
     });
-
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetExclusion}
    */
-  AlgoliaSearchHelper.prototype.removeExclude = function() {
+  AlgoliaSearchHelper.prototype.removeExclude = function () {
     return this.removeFacetExclusion.apply(this, arguments);
   };
 
@@ -10191,16 +9765,15 @@
    *
    * This method resets the current page to 0.
    * @param {string} tag tag to remove from the filter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeTag = function(tag) {
+  AlgoliaSearchHelper.prototype.removeTag = function (tag) {
     this._change({
       state: this.state.resetPage().removeTagRefinement(tag),
       isPageReset: true
     });
-
     return this;
   };
 
@@ -10211,23 +9784,23 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.toggleFacetExclusion = function(facet, value) {
+  AlgoliaSearchHelper.prototype.toggleFacetExclusion = function (facet, value) {
     this._change({
       state: this.state.resetPage().toggleExcludeFacetRefinement(facet, value),
       isPageReset: true
     });
-
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetExclusion}
    */
-  AlgoliaSearchHelper.prototype.toggleExclude = function() {
+  AlgoliaSearchHelper.prototype.toggleExclude = function () {
     return this.toggleFacetExclusion.apply(this, arguments);
   };
 
@@ -10240,13 +9813,13 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @throws Error will throw an error if the facet is not declared in the settings of the helper
    * @fires change
    * @chainable
    * @deprecated since version 2.19.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.toggleRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.toggleRefinement = function (facet, value) {
     return this.toggleFacetRefinement(facet, value);
   };
 
@@ -10259,24 +9832,24 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @throws Error will throw an error if the facet is not declared in the settings of the helper
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.toggleFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.toggleFacetRefinement = function (facet, value) {
     this._change({
       state: this.state.resetPage().toggleFacetRefinement(facet, value),
       isPageReset: true
     });
-
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.toggleRefine = function() {
+  AlgoliaSearchHelper.prototype.toggleRefine = function () {
     return this.toggleFacetRefinement.apply(this, arguments);
   };
 
@@ -10286,29 +9859,28 @@
    *
    * This method resets the current page to 0.
    * @param {string} tag tag to remove or add
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.toggleTag = function(tag) {
+  AlgoliaSearchHelper.prototype.toggleTag = function (tag) {
     this._change({
       state: this.state.resetPage().toggleTagRefinement(tag),
       isPageReset: true
     });
-
     return this;
   };
 
   /**
    * Increments the page number by one.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    * @example
    * helper.setPage(0).nextPage().getPage();
    * // returns 1
    */
-  AlgoliaSearchHelper.prototype.nextPage = function() {
+  AlgoliaSearchHelper.prototype.nextPage = function () {
     var page = this.state.page || 0;
     return this.setPage(page + 1);
   };
@@ -10316,28 +9888,30 @@
   /**
    * Decrements the page number by one.
    * @fires change
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @chainable
    * @example
    * helper.setPage(1).previousPage().getPage();
    * // returns 0
    */
-  AlgoliaSearchHelper.prototype.previousPage = function() {
+  AlgoliaSearchHelper.prototype.previousPage = function () {
     var page = this.state.page || 0;
     return this.setPage(page - 1);
   };
 
   /**
    * @private
+   * @param {number} page The page number
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @chainable
+   * @fires change
    */
   function setCurrentPage(page) {
     if (page < 0) throw new Error('Page requested below 0.');
-
     this._change({
       state: this.state.setPage(page),
       isPageReset: false
     });
-
     return this;
   }
 
@@ -10345,7 +9919,7 @@
    * Change the current page
    * @deprecated
    * @param  {number} page The page number
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
@@ -10355,7 +9929,7 @@
    * Updates the current page.
    * @function
    * @param  {number} page The page number
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
@@ -10366,16 +9940,15 @@
    *
    * This method resets the current page to 0.
    * @param {string} name the index name
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.setIndex = function(name) {
+  AlgoliaSearchHelper.prototype.setIndex = function (name) {
     this._change({
       state: this.state.resetPage().setIndex(name),
       isPageReset: true
     });
-
     return this;
   };
 
@@ -10390,34 +9963,32 @@
    * This method resets the current page to 0.
    * @param {string} parameter name of the parameter to update
    * @param {any} value new value of the parameter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    * @example
    * helper.setQueryParameter('hitsPerPage', 20).search();
    */
-  AlgoliaSearchHelper.prototype.setQueryParameter = function(parameter, value) {
+  AlgoliaSearchHelper.prototype.setQueryParameter = function (parameter, value) {
     this._change({
       state: this.state.resetPage().setQueryParameter(parameter, value),
       isPageReset: true
     });
-
     return this;
   };
 
   /**
    * Set the whole state (warning: will erase previous state)
    * @param {SearchParameters} newState the whole new state
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.setState = function(newState) {
+  AlgoliaSearchHelper.prototype.setState = function (newState) {
     this._change({
       state: SearchParameters_1.make(newState),
       isPageReset: false
     });
-
     return this;
   };
 
@@ -10426,7 +9997,7 @@
    * Do not use this method unless you know what you are doing. (see the example
    * for a legit use case)
    * @param {SearchParameters} newState the whole new state
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @example
    *  helper.on('change', function(state){
    *    // In this function you might want to find a way to store the state in the url/history
@@ -10438,7 +10009,7 @@
    *  }
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function(newState) {
+  AlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function (newState) {
     this.state = new SearchParameters_1(newState);
     return this;
   };
@@ -10466,7 +10037,7 @@
    * helper.hasRefinements('categories'); // true
    *
    */
-  AlgoliaSearchHelper.prototype.hasRefinements = function(attribute) {
+  AlgoliaSearchHelper.prototype.hasRefinements = function (attribute) {
     if (objectHasKeys_1(this.state.getNumericRefinements(attribute))) {
       return true;
     } else if (this.state.isConjunctiveFacet(attribute)) {
@@ -10491,7 +10062,7 @@
    *
    * @param  {string}  facet name of the attribute for used for faceting
    * @param  {string}  [value] optional value. If passed will test that this value
-     * is filtering the given facet.
+   * is filtering the given facet.
    * @return {boolean} true if refined
    * @example
    * helper.isExcludeRefined('color'); // false
@@ -10504,45 +10075,45 @@
    * helper.isExcludeRefined('color', 'blue') // false
    * helper.isExcludeRefined('color', 'red') // true
    */
-  AlgoliaSearchHelper.prototype.isExcluded = function(facet, value) {
+  AlgoliaSearchHelper.prototype.isExcluded = function (facet, value) {
     return this.state.isExcludeRefined(facet, value);
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasRefinements}
    */
-  AlgoliaSearchHelper.prototype.isDisjunctiveRefined = function(facet, value) {
+  AlgoliaSearchHelper.prototype.isDisjunctiveRefined = function (facet, value) {
     return this.state.isDisjunctiveFacetRefined(facet, value);
   };
 
   /**
    * Check if the string is a currently filtering tag.
    * @param {string} tag tag to check
-   * @return {boolean}
+   * @return {boolean} true if the tag is currently refined
    */
-  AlgoliaSearchHelper.prototype.hasTag = function(tag) {
+  AlgoliaSearchHelper.prototype.hasTag = function (tag) {
     return this.state.isTagRefined(tag);
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasTag}
    */
-  AlgoliaSearchHelper.prototype.isTagRefined = function() {
+  AlgoliaSearchHelper.prototype.isTagRefined = function () {
     return this.hasTagRefinements.apply(this, arguments);
   };
 
-
   /**
    * Get the name of the currently used index.
-   * @return {string}
+   * @return {string} name of the index
    * @example
    * helper.setIndex('highestPrice_products').getIndex();
    * // returns 'highestPrice_products'
    */
-  AlgoliaSearchHelper.prototype.getIndex = function() {
+  AlgoliaSearchHelper.prototype.getIndex = function () {
     return this.state.index;
   };
-
   function getCurrentPage() {
     return this.state.page;
   }
@@ -10565,7 +10136,7 @@
    *
    * @return {string[]} The list of tags currently set.
    */
-  AlgoliaSearchHelper.prototype.getTags = function() {
+  AlgoliaSearchHelper.prototype.getTags = function () {
     return this.state.tagRefinements;
   };
 
@@ -10613,50 +10184,41 @@
    * //   }
    * // ]
    */
-  AlgoliaSearchHelper.prototype.getRefinements = function(facetName) {
+  AlgoliaSearchHelper.prototype.getRefinements = function (facetName) {
     var refinements = [];
-
     if (this.state.isConjunctiveFacet(facetName)) {
       var conjRefinements = this.state.getConjunctiveRefinements(facetName);
-
-      conjRefinements.forEach(function(r) {
+      conjRefinements.forEach(function (r) {
         refinements.push({
           value: r,
           type: 'conjunctive'
         });
       });
-
       var excludeRefinements = this.state.getExcludeRefinements(facetName);
-
-      excludeRefinements.forEach(function(r) {
+      excludeRefinements.forEach(function (r) {
         refinements.push({
           value: r,
           type: 'exclude'
         });
       });
     } else if (this.state.isDisjunctiveFacet(facetName)) {
-      var disjRefinements = this.state.getDisjunctiveRefinements(facetName);
-
-      disjRefinements.forEach(function(r) {
+      var disjunctiveRefinements = this.state.getDisjunctiveRefinements(facetName);
+      disjunctiveRefinements.forEach(function (r) {
         refinements.push({
           value: r,
           type: 'disjunctive'
         });
       });
     }
-
     var numericRefinements = this.state.getNumericRefinements(facetName);
-
-    Object.keys(numericRefinements).forEach(function(operator) {
+    Object.keys(numericRefinements).forEach(function (operator) {
       var value = numericRefinements[operator];
-
       refinements.push({
         value: value,
         operator: operator,
         type: 'numeric'
       });
     });
-
     return refinements;
   };
 
@@ -10666,7 +10228,7 @@
    * @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);
   };
 
@@ -10675,7 +10237,7 @@
    * @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);
   };
 
@@ -10684,72 +10246,60 @@
   /**
    * Perform the underlying queries
    * @private
-   * @return {undefined}
+   * @param {object} options options for the query
+   * @param {boolean} [options.onlyWithDerivedHelpers=false] if true, only the derived helpers will be queried
+   * @return {undefined} does not return anything
    * @fires search
    * @fires result
    * @fires error
    */
-  AlgoliaSearchHelper.prototype._search = function(options) {
+  AlgoliaSearchHelper.prototype._search = function (options) {
     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
       });
-
       this.emit('search', {
         state: state,
         results: this.lastResults
       });
     }
-
-    var derivedQueries = this.derivedHelpers.map(function(derivedHelper) {
+    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
       });
-
       derivedHelper.emit('search', {
         state: derivedState,
         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
       });
     }
+    return undefined;
   };
 
   /**
@@ -10757,33 +10307,27 @@
    * usable object that merge the results of all the batch requests. It will dispatch
    * over the different helper + derived helpers (when there are some).
    * @private
-   * @param {array.<{SearchParameters, AlgoliaQueries, AlgoliaSearchHelper}>}
-   *  state state used for to generate the request
+   * @param {array.<{SearchParameters, AlgoliaQueries, AlgoliaSearchHelper}>} states state used to generate the request
    * @param {number} queryId id of the current request
    * @param {object} content content of the response
    * @return {undefined}
    */
-  AlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function(states, queryId, content) {
-    // FIXME remove the number of outdated queries discarded instead of just one
+  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._currentNbQueries -= queryId - this._lastQueryIdReceived;
     this._lastQueryIdReceived = queryId;
-
     if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');
-
     var results = content.results.slice();
-
-    states.forEach(function(s) {
+    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,
@@ -10791,57 +10335,43 @@
         });
         return;
       }
-
-      var formattedResponse = helper.lastResults = new SearchResults_1(state, specificResults);
-
+      helper.lastResults = new SearchResults_1(state, specificResults);
       helper.emit('result', {
-        results: formattedResponse,
+        results: helper.lastResults,
         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
     });
-
     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;
   };
 
   /**
    * Test if there are some disjunctive refinements on the facet
    * @private
    * @param {string} facet the attribute to test
-   * @return {boolean}
+   * @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;
+  AlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function (facet) {
+    return this.state.disjunctiveRefinements[facet] && this.state.disjunctiveRefinements[facet].length > 0;
   };
-
-  AlgoliaSearchHelper.prototype._change = function(event) {
+  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,
@@ -10852,10 +10382,10 @@
 
   /**
    * Clears the cache of the underlying Algolia client.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    */
-  AlgoliaSearchHelper.prototype.clearCache = function() {
-    this.client.clearCache && this.client.clearCache();
+  AlgoliaSearchHelper.prototype.clearCache = function () {
+    if (this.client.clearCache) this.client.clearCache();
     return this;
   };
 
@@ -10863,24 +10393,22 @@
    * Updates the internal client instance. If the reference of the clients
    * are equal then no update is actually done.
    * @param  {AlgoliaSearch} newClient an AlgoliaSearch client
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    */
-  AlgoliaSearchHelper.prototype.setClient = function(newClient) {
+  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;
   };
 
   /**
    * Gets the instance of the currently used client.
-   * @return {AlgoliaSearch}
+   * @return {AlgoliaSearch} the currently used client
    */
-  AlgoliaSearchHelper.prototype.getClient = function() {
+  AlgoliaSearchHelper.prototype.getClient = function () {
     return this.client;
   };
 
@@ -10901,9 +10429,9 @@
    * and the SearchParameters that is returned by the call of the
    * parameter function.
    * @param {function} fn SearchParameters -> SearchParameters
-   * @return {DerivedHelper}
+   * @return {DerivedHelper} a new DerivedHelper
    */
-  AlgoliaSearchHelper.prototype.derive = function(fn) {
+  AlgoliaSearchHelper.prototype.derive = function (fn) {
     var derivedHelper = new DerivedHelper_1(this, fn);
     this.derivedHelpers.push(derivedHelper);
     return derivedHelper;
@@ -10913,10 +10441,11 @@
    * This method detaches a derived Helper from the main one. Prefer using the one from the
    * derived helper itself, to remove the event listeners too.
    * @private
-   * @return {undefined}
+   * @param  {DerivedHelper} derivedHelper the derived helper to detach
+   * @return {undefined} nothing is returned
    * @throws Error
    */
-  AlgoliaSearchHelper.prototype.detachDerivedHelper = function(derivedHelper) {
+  AlgoliaSearchHelper.prototype.detachDerivedHelper = function (derivedHelper) {
     var pos = this.derivedHelpers.indexOf(derivedHelper);
     if (pos === -1) throw new Error('Derived helper already detached');
     this.derivedHelpers.splice(pos, 1);
@@ -10926,7 +10455,7 @@
    * This method returns true if there is currently at least one on-going search.
    * @return {boolean} true if there is a search pending
    */
-  AlgoliaSearchHelper.prototype.hasPendingRequests = function() {
+  AlgoliaSearchHelper.prototype.hasPendingRequests = function () {
     return this._currentNbQueries > 0;
   };
 
@@ -10977,7 +10506,7 @@
    * @param  {AlgoliaSearch} client an AlgoliaSearch client
    * @param  {string} index the name of the index to query
    * @param  {SearchParameters|object} opts an object defining the initial config of the search. It doesn't have to be a {SearchParameters}, just an object containing the properties you need from it.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} The helper instance
    */
   function algoliasearchHelper(client, index, opts) {
     return new algoliasearch_helper(client, index, opts);
@@ -11010,7 +10539,6 @@
    * @type {SearchResults}
    */
   algoliasearchHelper.SearchResults = SearchResults_1;
-
   var algoliasearchHelper_1 = algoliasearchHelper;
 
   var withUsage$l = createDocumentationMessageGenerator({
@@ -12365,7 +11893,7 @@
       return obj;
   };
 
-  var merge$1 = function merge(target, source, options) {
+  var merge$2 = function merge(target, source, options) {
       /* eslint no-param-reassign: 0 */
       if (!source) {
           return target;
@@ -12569,7 +12097,7 @@
       isBuffer: isBuffer,
       isRegExp: isRegExp,
       maybeMap: maybeMap,
-      merge: merge$1
+      merge: merge$2
   };
 
   var has$1 = Object.prototype.hasOwnProperty;
@@ -13472,9 +13000,17 @@
     return function (_ref) {
       var instantSearchInstance = _ref.instantSearchInstance;
       function topLevelCreateURL(nextState) {
+        var previousUiState =
+        // If only the mainIndex is initialized, we don't yet know what other
+        // index widgets are used. Therefore we fall back to the initialUiState.
+        // We can't indiscriminately use the initialUiState because then we
+        // reintroduce state that was changed by the user.
+        // When there are no widgets, we are sure the user can't yet have made
+        // any changes.
+        instantSearchInstance.mainIndex.getWidgets().length === 0 ? instantSearchInstance._initialUiState : instantSearchInstance.mainIndex.getWidgetUiState({});
         var uiState = Object.keys(nextState).reduce(function (acc, indexId) {
           return _objectSpread2(_objectSpread2({}, acc), {}, _defineProperty({}, indexId, nextState[indexId]));
-        }, instantSearchInstance.mainIndex.getWidgetUiState({}));
+        }, previousUiState);
         var route = stateMapping.stateToRoute(uiState);
         return router.createURL(route);
       }
@@ -13640,6 +13176,9 @@
         return localParent;
       },
       createURL: function createURL(nextState) {
+        if (typeof nextState === 'function') {
+          return localInstantSearchInstance._createURL(_defineProperty({}, indexId, nextState(localUiState)));
+        }
         return localInstantSearchInstance._createURL(_defineProperty({}, indexId, getLocalWidgetsUiState(localWidgets, {
           searchParameters: nextState,
           helper: helper
@@ -13704,7 +13243,7 @@
           return widgets.indexOf(widget) === -1;
         });
         if (localInstantSearchInstance && Boolean(widgets.length)) {
-          var nextState = widgets.reduce(function (state, widget) {
+          var _nextState = widgets.reduce(function (state, widget) {
             // the `dispose` method exists at this point we already assert it
             var next = widget.dispose({
               helper: helper,
@@ -13714,12 +13253,12 @@
             return next || state;
           }, helper.state);
           localUiState = getLocalWidgetsUiState(localWidgets, {
-            searchParameters: nextState,
+            searchParameters: _nextState,
             helper: helper
           });
           helper.setState(getLocalWidgetsSearchParameters(localWidgets, {
             uiState: localUiState,
-            initialSearchParameters: nextState
+            initialSearchParameters: _nextState
           }));
           if (localWidgets.length) {
             localInstantSearchInstance.scheduleSearch();
@@ -14049,7 +13588,7 @@
     };
   }
 
-  var version$1 = '4.56.4';
+  var version$1 = '4.56.6';
 
   var withUsage$r = createDocumentationMessageGenerator({
     name: 'instantsearch'