react-instantsearch 7.31.0 → 7.32.0

package/dist/umd/ReactInstantSearch.js

@@ -1,4 +1,4 @@
-/*! React InstantSearch 7.31.0 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
+/*! React InstantSearch 7.32.0 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
     typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
@@ -24,7 +24,7 @@
 
     var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
-    var version$2 = '7.31.0';
+    var version$2 = '7.32.0';
 
     function _define_property(obj, key, value) {
         if (key in obj) {
@@ -3919,7 +3919,7 @@
     function requireVersion() {
         if (hasRequiredVersion) return version$1;
         hasRequiredVersion = 1;
-        version$1 = '3.28.2';
+        version$1 = '3.29.0';
         return version$1;
     }
 
@@ -5293,7 +5293,6 @@
                 var derivedStateQueries = requestBuilder._getCompositionQueries(derivedState);
                 states.push({
                     state: derivedState,
-                    queriesCount: derivedStateQueries.length,
                     helper: derivedHelper
                 });
                 derivedHelper.emit('search', {
@@ -5423,7 +5422,7 @@
                 var state = s.state;
                 var queriesCount = s.queriesCount;
                 var helper = s.helper;
-                var specificResults = results.splice(0, queriesCount);
+                var specificResults = queriesCount !== undefined ? results.splice(0, queriesCount) : results;
                 if (!state.index) {
                     helper.emit('result', {
                         results: null,
@@ -5431,8 +5430,24 @@
                     });
                     return;
                 }
-                helper.lastResults = new SearchResults(state, specificResults, self._searchResultsOptions);
-                if (rawContent !== undefined) helper.lastResults._rawContent = rawContent;
+                // Multifeed composition: build ordered SearchResults array on lastResults
+                if (specificResults.length > 0 && specificResults[0].feedID) {
+                    var feeds = specificResults.map(function(r) {
+                        var sr = new SearchResults(state, [
+                            r
+                        ], self._searchResultsOptions);
+                        if (rawContent !== undefined) sr._rawContent = rawContent;
+                        return sr;
+                    });
+                    helper.lastResults = new SearchResults(state, [
+                        specificResults[0]
+                    ], self._searchResultsOptions);
+                    helper.lastResults.feeds = feeds;
+                    if (rawContent !== undefined) helper.lastResults._rawContent = rawContent;
+                } else {
+                    helper.lastResults = new SearchResults(state, specificResults, self._searchResultsOptions);
+                    if (rawContent !== undefined) helper.lastResults._rawContent = rawContent;
+                }
                 helper.emit('result', {
                     results: helper.lastResults,
                     state: state
@@ -5965,7 +5980,7 @@
         }
     }
 
-    var withUsage$t = createDocumentationMessageGenerator({
+    var withUsage$u = createDocumentationMessageGenerator({
         name: 'configure',
         connector: true
     });
@@ -5981,7 +5996,7 @@
         var renderFn = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : noop, unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
         return function(widgetParams) {
             if (!widgetParams || !isPlainObject(widgetParams.searchParameters)) {
-                throw new Error(withUsage$t('The `searchParameters` option expects an object.'));
+                throw new Error(withUsage$u('The `searchParameters` option expects an object.'));
             }
             var connectorState = {};
             function refine(helper) {
@@ -6252,131 +6267,1239 @@
         return stableValue;
     }
 
-    var useKey = 'use';
-    // @TODO: Remove this file and import directly from React when available.
-    var use = React__namespace[useKey];
+    var id$1 = 0;
+    function addWidgetId(widget) {
+        if (widget.dependsOn !== 'recommend') {
+            return;
+        }
+        widget.$$id = id$1++;
+    }
+    function resetWidgetId() {
+        id$1 = 0;
+    }
 
-    /**
-     * `useLayoutEffect` that doesn't show a warning when server-side rendering.
-     *
-     * It uses `useEffect` on the server (no-op), and `useLayoutEffect` on the browser.
-     */ var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;
+    function _array_without_holes(arr) {
+        if (Array.isArray(arr)) return _array_like_to_array(arr);
+    }
 
-    var InstantSearchRSCContext = /*#__PURE__*/ React.createContext({
-        countRef: {
-            current: 0
-        },
-        waitForResultsRef: null,
-        ignoreMultipleHooksWarning: false
-    });
+    function _non_iterable_spread() {
+        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
 
-    function useRSCContext() {
-        return React.useContext(InstantSearchRSCContext);
+    function _to_consumable_array(arr) {
+        return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
     }
 
-    function useWidget(param) {
-        var widget = param.widget, parentIndex = param.parentIndex, props = param.props, shouldSsr = param.shouldSsr, skipSuspense = param.skipSuspense;
-        var _waitForResultsRef_current, _waitForResultsRef_current1;
-        var _useRSCContext = useRSCContext(), waitForResultsRef = _useRSCContext.waitForResultsRef, countRef = _useRSCContext.countRef;
-        _useRSCContext.ignoreMultipleHooksWarning;
-        var prevPropsRef = React.useRef(props);
-        React.useEffect(function() {
-            prevPropsRef.current = props;
-        }, [
-            props
-        ]);
-        var prevWidgetRef = React.useRef(widget);
-        React.useEffect(function() {
-            prevWidgetRef.current = widget;
-        }, [
-            widget
-        ]);
-        var cleanupTimerRef = React.useRef(null);
-        var shouldAddWidgetEarly = shouldSsr && !parentIndex.getWidgets().includes(widget);
-        var search = useInstantSearchContext();
-        // This effect is responsible for adding, removing, and updating the widget.
-        // We need to support scenarios where the widget is remounted quickly, like in
-        // Strict Mode, so that we don't lose its state, and therefore that we don't
-        // break routing.
-        useIsomorphicLayoutEffect(function() {
-            var previousWidget = prevWidgetRef.current;
-            // Scenario 1: the widget is added for the first time.
-            if (!cleanupTimerRef.current) {
-                if (!shouldSsr) {
-                    parentIndex.addWidgets([
-                        widget
-                    ]);
-                }
-            } else {
-                // We cancel the original effect cleanup because it may not be necessary if
-                // props haven't changed. (We manually call it if it is below.)
-                clearTimeout(cleanupTimerRef.current);
-                // Warning: if an unstable function prop is provided, `dequal` is not able
-                // to keep its reference and therefore will consider that props did change.
-                // This could unsollicitely remove/add the widget, therefore forget its state,
-                // and could be a source of confusion.
-                // If users face this issue, we should advise them to provide stable function
-                // references.
-                var arePropsEqual = dequal(props, prevPropsRef.current);
-                // If props did change, then we execute the cleanup function instantly
-                // and then add the widget back. This lets us add the widget without
-                // waiting for the scheduled cleanup function to finish (that we canceled
-                // above).
-                if (!arePropsEqual) {
-                    parentIndex.removeWidgets([
-                        previousWidget
-                    ]);
-                    parentIndex.addWidgets([
-                        widget
-                    ]);
-                }
+    function getObjectType(object) {
+        return Object.prototype.toString.call(object).slice(8, -1);
+    }
+
+    function checkRendering(rendering, usage) {
+        if (rendering === undefined || typeof rendering !== 'function') {
+            throw new Error("The render function is not valid (received type ".concat(getObjectType(rendering), ").\n\n").concat(usage));
+        }
+    }
+
+    /**
+     * Clears the refinements of a SearchParameters object based on rules provided.
+     * The included attributes list is applied before the excluded attributes list. If the list
+     * is not provided, this list of all the currently refined attributes is used as included attributes.
+     * @returns search parameters with refinements cleared
+     */ function clearRefinements(param) {
+        var helper = param.helper, _param_attributesToClear = param.attributesToClear, attributesToClear = _param_attributesToClear === void 0 ? [] : _param_attributesToClear;
+        var finalState = helper.state.setPage(0);
+        finalState = attributesToClear.reduce(function(state, attribute) {
+            if (finalState.isNumericRefined(attribute)) {
+                return state.removeNumericRefinement(attribute);
             }
-            return function() {
-                // We don't remove the widget right away, but rather schedule it so that
-                // we're able to cancel it in the next effect.
-                cleanupTimerRef.current = setTimeout(function() {
-                    search._schedule(function() {
-                        if (search._preventWidgetCleanup) return;
-                        parentIndex.removeWidgets([
-                            previousWidget
-                        ]);
-                    });
-                });
-            };
-        }, [
-            parentIndex,
-            widget,
-            shouldSsr,
-            search,
-            props
-        ]);
-        if (shouldAddWidgetEarly || (waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : (_waitForResultsRef_current = waitForResultsRef.current) === null || _waitForResultsRef_current === void 0 ? void 0 : _waitForResultsRef_current.status) === 'pending') {
-            parentIndex.addWidgets([
-                widget
-            ]);
+            if (finalState.isHierarchicalFacet(attribute)) {
+                return state.removeHierarchicalFacetRefinement(attribute);
+            }
+            if (finalState.isDisjunctiveFacet(attribute)) {
+                return state.removeDisjunctiveFacetRefinement(attribute);
+            }
+            if (finalState.isConjunctiveFacet(attribute)) {
+                return state.removeFacetRefinement(attribute);
+            }
+            return state;
+        }, finalState);
+        if (attributesToClear.indexOf('query') !== -1) {
+            finalState = finalState.setQuery('');
         }
-        if ((waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : waitForResultsRef.current) && !skipSuspense) {
-            var _search_helper;
-            use(waitForResultsRef.current);
-            // If we made a second request because of DynamicWidgets, we need to wait for the second result,
-            // except for DynamicWidgets itself which needs to render its children after the first result.
-            if (widget.$$type !== 'ais.dynamicWidgets' && ((_search_helper = search.helper) === null || _search_helper === void 0 ? void 0 : _search_helper.lastResults)) {
-                use(waitForResultsRef.current);
+        return finalState;
+    }
+
+    function _extends() {
+        _extends = Object.assign || function assign(target) {
+            for (var i = 1; i < arguments.length; i++) {
+                var source = arguments[i];
+                for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
             }
+
+            return target;
+        };
+
+        return _extends.apply(this, arguments);
+    }
+
+    function _object_destructuring_empty(o) {
+        if (o === null || o === void 0) throw new TypeError("Cannot destructure " + o);
+
+        return o;
+    }
+
+    /**
+     * This implementation is taken from Lodash implementation.
+     * See: https://github.com/lodash/lodash/blob/4.17.11-npm/escape.js
+     */ // Used to map characters to HTML entities.
+    var htmlEntities = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#39;'
+    };
+    // Used to match HTML entities and HTML characters.
+    var regexUnescapedHtml = /[&<>"']/g;
+    var regexHasUnescapedHtml = RegExp(regexUnescapedHtml.source);
+    /**
+     * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
+     * corresponding HTML entities.
+     */ function escape$1(value) {
+        return value && regexHasUnescapedHtml.test(value) ? value.replace(regexUnescapedHtml, function(character) {
+            return htmlEntities[character];
+        }) : value;
+    }
+    /**
+     * This implementation is taken from Lodash implementation.
+     * See: https://github.com/lodash/lodash/blob/4.17.11-npm/unescape.js
+     */ // Used to map HTML entities to characters.
+    var htmlCharacters = {
+        '&amp;': '&',
+        '&lt;': '<',
+        '&gt;': '>',
+        '&quot;': '"',
+        '&#39;': "'"
+    };
+    // Used to match HTML entities and HTML characters.
+    var regexEscapedHtml = /&(amp|quot|lt|gt|#39);/g;
+    var regexHasEscapedHtml = RegExp(regexEscapedHtml.source);
+    /**
+     * Converts the HTML entities "&", "<", ">", '"', and "'" in `string` to their
+     * characters.
+     */ function unescape$1(value) {
+        return value && regexHasEscapedHtml.test(value) ? value.replace(regexEscapedHtml, function(character) {
+            return htmlCharacters[character];
+        }) : value;
+    }
+
+    var TAG_PLACEHOLDER = {
+        highlightPreTag: '__ais-highlight__',
+        highlightPostTag: '__/ais-highlight__'
+    };
+    var TAG_REPLACEMENT = {
+        highlightPreTag: '<mark>',
+        highlightPostTag: '</mark>'
+    };
+    // @MAJOR: in the future, this should only escape, not replace
+    function replaceTagsAndEscape(value) {
+        return escape$1(value).replace(new RegExp(TAG_PLACEHOLDER.highlightPreTag, 'g'), TAG_REPLACEMENT.highlightPreTag).replace(new RegExp(TAG_PLACEHOLDER.highlightPostTag, 'g'), TAG_REPLACEMENT.highlightPostTag);
+    }
+    function recursiveEscape(input) {
+        if (isPlainObject(input) && typeof input.value !== 'string') {
+            return Object.keys(input).reduce(function(acc, key) {
+                return _object_spread_props(_object_spread({}, acc), _define_property({}, key, recursiveEscape(input[key])));
+            }, {});
         }
-        if ((waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : (_waitForResultsRef_current1 = waitForResultsRef.current) === null || _waitForResultsRef_current1 === void 0 ? void 0 : _waitForResultsRef_current1.status) === 'fulfilled') {
-            countRef.current += 1;
+        if (Array.isArray(input)) {
+            return input.map(recursiveEscape);
         }
+        return _object_spread_props(_object_spread({}, input), {
+            value: replaceTagsAndEscape(input.value)
+        });
     }
-
-    function useConnector(connector) {
-        var _1 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0, _2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : void 0;
-        var _ref = [
-            _1,
-            _2
-        ], _ref1 = _to_array(_ref), tmp = _ref1[0], props = tmp === void 0 ? {} : tmp, _rest = _ref1.slice(1), _rest1 = _sliced_to_array(_rest, 1), tmp1 = _rest1[0], _ref2 = tmp1 === void 0 ? {} : tmp1, _ref_skipSuspense = _ref2.skipSuspense, skipSuspense = _ref_skipSuspense === void 0 ? false : _ref_skipSuspense, additionalWidgetProperties = _object_without_properties(_ref2, [
-            "skipSuspense"
-        ]);
+    function escapeHits(hits) {
+        if (hits.__escaped === undefined) {
+            // We don't override the value on hit because it will mutate the raw results
+            // instead we make a shallow copy and we assign the escaped values on it.
+            hits = hits.map(function(_0) {
+                _object_destructuring_empty(_0);
+                var hit = _extends({}, _0);
+                if (hit._highlightResult) {
+                    hit._highlightResult = recursiveEscape(hit._highlightResult);
+                }
+                if (hit._snippetResult) {
+                    hit._snippetResult = recursiveEscape(hit._snippetResult);
+                }
+                return hit;
+            });
+            hits.__escaped = true;
+        }
+        return hits;
+    }
+    function escapeFacets(facetHits) {
+        return facetHits.map(function(h) {
+            return _object_spread_props(_object_spread({}, h), {
+                highlighted: replaceTagsAndEscape(h.highlighted)
+            });
+        });
+    }
+
+    function concatHighlightedParts(parts) {
+        var highlightPreTag = TAG_REPLACEMENT.highlightPreTag, highlightPostTag = TAG_REPLACEMENT.highlightPostTag;
+        return parts.map(function(part) {
+            return part.isHighlighted ? highlightPreTag + part.value + highlightPostTag : part.value;
+        }).join('');
+    }
+
+    function isFacetRefined(helper, facet, value) {
+        if (helper.state.isHierarchicalFacet(facet)) {
+            return helper.state.isHierarchicalFacetRefined(facet, value);
+        } else if (helper.state.isConjunctiveFacet(facet)) {
+            return helper.state.isFacetRefined(facet, value);
+        } else {
+            return helper.state.isDisjunctiveFacetRefined(facet, value);
+        }
+    }
+
+    function createSendEventForFacet(param) {
+        var instantSearchInstance = param.instantSearchInstance, helper = param.helper, attr = param.attribute, widgetType = param.widgetType;
+        var sendEventForFacet = function sendEventForFacet() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            var _args = _sliced_to_array(args, 4), facetValue = _args[1], tmp = _args[2], eventName = tmp === void 0 ? 'Filter Applied' : tmp, tmp1 = _args[3], additionalData = tmp1 === void 0 ? {} : tmp1;
+            var _args__split = _sliced_to_array(args[0].split(':'), 2), eventType = _args__split[0], eventModifier = _args__split[1];
+            var attribute = typeof attr === 'string' ? attr : attr(facetValue);
+            if (args.length === 1 && _type_of(args[0]) === 'object') {
+                instantSearchInstance.sendEventToInsights(args[0]);
+            } else if (eventType === 'click' && args.length >= 2 && args.length <= 4) {
+                if (!isFacetRefined(helper, attribute, facetValue)) {
+                    var _helper_lastResults;
+                    // send event only when the facet is being checked "ON"
+                    instantSearchInstance.sendEventToInsights({
+                        insightsMethod: 'clickedFilters',
+                        widgetType: widgetType,
+                        eventType: eventType,
+                        eventModifier: eventModifier,
+                        payload: _object_spread({
+                            eventName: eventName,
+                            index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
+                            filters: [
+                                "".concat(attribute, ":").concat(facetValue)
+                            ]
+                        }, additionalData),
+                        attribute: attribute
+                    });
+                }
+            } else ;
+        };
+        return sendEventForFacet;
+    }
+
+    function serializePayload(payload) {
+        return btoa(encodeURIComponent(JSON.stringify(payload)));
+    }
+
+    function chunk(arr) {
+        var chunkSize = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 20;
+        var chunks = [];
+        for(var i = 0; i < Math.ceil(arr.length / chunkSize); i++){
+            chunks.push(arr.slice(i * chunkSize, (i + 1) * chunkSize));
+        }
+        return chunks;
+    }
+    function _buildEventPayloadsForHits(param) {
+        var helper = param.helper, widgetType = param.widgetType;
+        param.methodName;
+        var args = param.args, instantSearchInstance = param.instantSearchInstance;
+        // when there's only one argument, that means it's custom
+        if (args.length === 1 && _type_of(args[0]) === 'object') {
+            return [
+                args[0]
+            ];
+        }
+        var _args__split = _sliced_to_array(args[0].split(':'), 2), eventType = _args__split[0], eventModifier = _args__split[1];
+        var hits = args[1];
+        var eventName = args[2];
+        var additionalData = args[3] || {};
+        if (!hits) {
+            {
+                return [];
+            }
+        }
+        if ((eventType === 'click' || eventType === 'conversion') && !eventName) {
+            {
+                return [];
+            }
+        }
+        var hitsArray = Array.isArray(hits) ? hits : [
+            hits
+        ];
+        if (hitsArray.length === 0) {
+            return [];
+        }
+        var queryID = hitsArray[0].__queryID;
+        var hitsChunks = chunk(hitsArray);
+        var objectIDsByChunk = hitsChunks.map(function(batch) {
+            return batch.map(function(hit) {
+                return hit.objectID;
+            });
+        });
+        var positionsByChunk = hitsChunks.map(function(batch) {
+            return batch.map(function(hit) {
+                return hit.__position;
+            });
+        });
+        if (eventType === 'view') {
+            if (instantSearchInstance.status !== 'idle') {
+                return [];
+            }
+            return hitsChunks.map(function(batch, i) {
+                var _helper_lastResults;
+                return {
+                    insightsMethod: 'viewedObjectIDs',
+                    widgetType: widgetType,
+                    eventType: eventType,
+                    payload: _object_spread({
+                        eventName: eventName || 'Hits Viewed',
+                        index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
+                        objectIDs: objectIDsByChunk[i]
+                    }, additionalData),
+                    hits: batch,
+                    eventModifier: eventModifier
+                };
+            });
+        } else if (eventType === 'click') {
+            return hitsChunks.map(function(batch, i) {
+                var _helper_lastResults;
+                return {
+                    insightsMethod: 'clickedObjectIDsAfterSearch',
+                    widgetType: widgetType,
+                    eventType: eventType,
+                    payload: _object_spread({
+                        eventName: eventName || 'Hit Clicked',
+                        index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
+                        queryID: queryID,
+                        objectIDs: objectIDsByChunk[i],
+                        positions: positionsByChunk[i]
+                    }, additionalData),
+                    hits: batch,
+                    eventModifier: eventModifier
+                };
+            });
+        } else if (eventType === 'conversion') {
+            return hitsChunks.map(function(batch, i) {
+                var _helper_lastResults;
+                return {
+                    insightsMethod: 'convertedObjectIDsAfterSearch',
+                    widgetType: widgetType,
+                    eventType: eventType,
+                    payload: _object_spread({
+                        eventName: eventName || 'Hit Converted',
+                        index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
+                        queryID: queryID,
+                        objectIDs: objectIDsByChunk[i]
+                    }, additionalData),
+                    hits: batch,
+                    eventModifier: eventModifier
+                };
+            });
+        } else {
+            return [];
+        }
+    }
+    function createSendEventForHits(param) {
+        var instantSearchInstance = param.instantSearchInstance, helper = param.helper, widgetType = param.widgetType;
+        var sentEvents = {};
+        var timer = undefined;
+        var sendEventForHits = function sendEventForHits() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            var payloads = _buildEventPayloadsForHits({
+                widgetType: widgetType,
+                helper: helper,
+                methodName: 'sendEvent',
+                args: args,
+                instantSearchInstance: instantSearchInstance
+            });
+            payloads.forEach(function(payload) {
+                if (payload.eventType === 'click' && payload.eventModifier === 'internal' && sentEvents[payload.eventType]) {
+                    return;
+                }
+                sentEvents[payload.eventType] = true;
+                instantSearchInstance.sendEventToInsights(payload);
+            });
+            clearTimeout(timer);
+            timer = setTimeout(function() {
+                sentEvents = {};
+            }, 0);
+        };
+        return sendEventForHits;
+    }
+    function createBindEventForHits(param) {
+        var helper = param.helper, widgetType = param.widgetType, instantSearchInstance = param.instantSearchInstance;
+        var bindEventForHits = function bindEventForHits() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            var payloads = _buildEventPayloadsForHits({
+                widgetType: widgetType,
+                helper: helper,
+                methodName: 'bindEvent',
+                args: args,
+                instantSearchInstance: instantSearchInstance
+            });
+            return payloads.length ? "data-insights-event=".concat(serializePayload(payloads)) : '';
+        };
+        return bindEventForHits;
+    }
+
+    var indexWidgetTypes = [
+        'ais.index',
+        'ais.feedContainer'
+    ];
+
+    function isIndexWidget(widget) {
+        return indexWidgetTypes.includes(widget.$$type);
+    }
+
+    function setIndexHelperState(finalUiState, indexWidget) {
+        var nextIndexUiState = finalUiState[indexWidget.getIndexId()] || {};
+        indexWidget.getHelper().setState(indexWidget.getWidgetSearchParameters(indexWidget.getHelper().state, {
+            uiState: nextIndexUiState
+        }));
+        indexWidget.getWidgets().filter(isIndexWidget).forEach(function(widget) {
+            return setIndexHelperState(finalUiState, widget);
+        });
+    }
+
+    var nextMicroTask = Promise.resolve();
+    function defer(callback) {
+        var progress = null;
+        var cancelled = false;
+        var fn = function fn() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            if (progress !== null) {
+                return;
+            }
+            progress = nextMicroTask.then(function() {
+                progress = null;
+                if (cancelled) {
+                    cancelled = false;
+                    return;
+                }
+                callback.apply(void 0, _to_consumable_array(args));
+            });
+        };
+        fn.wait = function() {
+            if (progress === null) {
+                throw new Error('The deferred function should be called before calling `wait()`');
+            }
+            return progress;
+        };
+        fn.cancel = function() {
+            if (progress === null) {
+                return;
+            }
+            cancelled = true;
+        };
+        return fn;
+    }
+
+    function sendChatMessageFeedback(param) {
+        var agentId = param.agentId, vote = param.vote, messageId = param.messageId, appId = param.appId, apiKey = param.apiKey;
+        return fetch("https://".concat(appId, ".algolia.net/agent-studio/1/feedback"), {
+            method: 'POST',
+            body: JSON.stringify({
+                messageId: messageId,
+                agentId: agentId,
+                vote: vote
+            }),
+            headers: {
+                'x-algolia-application-id': appId,
+                'x-algolia-api-key': apiKey,
+                'content-type': 'application/json'
+            }
+        }).then(function(response) {
+            if (response.status >= 300) {
+                return response.json().then(function(data) {
+                    throw new Error("Feedback request failed with status ".concat(response.status, ": ").concat(data.message));
+                });
+            }
+            return response.json();
+        });
+    }
+
+    function unescapeFacetValue(value) {
+        if (typeof value === 'string') {
+            return value.replace(/^\\-/, '-');
+        }
+        return value;
+    }
+    function escapeFacetValue(value) {
+        if (typeof value === 'number' && value < 0 || typeof value === 'string') {
+            return String(value).replace(/^-/, '\\-');
+        }
+        return value;
+    }
+
+    // We aren't using the native `Array.prototype.find` because the refactor away from Lodash is not
+    // published as a major version.
+    // Relying on the `find` polyfill on user-land, which before was only required for niche use-cases,
+    // was decided as too risky.
+    // @MAJOR Replace with the native `Array.prototype.find` method
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
+    function find$1(items, predicate) {
+        var value;
+        for(var i = 0; i < items.length; i++){
+            value = items[i];
+            // inlined for performance: if (Call(predicate, thisArg, [value, i, list])) {
+            if (predicate(value, i, items)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+
+    var latLngRegExp = /^(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)$/;
+    function aroundLatLngToPosition(value) {
+        var pattern = value.match(latLngRegExp);
+        // Since the value provided is the one send with the request, the API should
+        // throw an error due to the wrong format. So throw an error should be safe.
+        if (!pattern) {
+            throw new Error('Invalid value for "aroundLatLng" parameter: "'.concat(value, '"'));
+        }
+        return {
+            lat: parseFloat(pattern[1]),
+            lng: parseFloat(pattern[2])
+        };
+    }
+    function insideBoundingBoxArrayToBoundingBox(value) {
+        var _value = _sliced_to_array(value, 1), tmp = _value[0], _ref = _sliced_to_array(tmp === void 0 ? [
+            undefined,
+            undefined,
+            undefined,
+            undefined
+        ] : tmp, 4), neLat = _ref[0], neLng = _ref[1], swLat = _ref[2], swLng = _ref[3];
+        // Since the value provided is the one send with the request, the API should
+        // throw an error due to the wrong format. So throw an error should be safe.
+        if (!neLat || !neLng || !swLat || !swLng) {
+            throw new Error('Invalid value for "insideBoundingBox" parameter: ['.concat(value, "]"));
+        }
+        return {
+            northEast: {
+                lat: neLat,
+                lng: neLng
+            },
+            southWest: {
+                lat: swLat,
+                lng: swLng
+            }
+        };
+    }
+    function insideBoundingBoxStringToBoundingBox(value) {
+        var _value_split_map = _sliced_to_array(value.split(',').map(parseFloat), 4), neLat = _value_split_map[0], neLng = _value_split_map[1], swLat = _value_split_map[2], swLng = _value_split_map[3];
+        // Since the value provided is the one send with the request, the API should
+        // throw an error due to the wrong format. So throw an error should be safe.
+        if (!neLat || !neLng || !swLat || !swLng) {
+            throw new Error('Invalid value for "insideBoundingBox" parameter: "'.concat(value, '"'));
+        }
+        return {
+            northEast: {
+                lat: neLat,
+                lng: neLng
+            },
+            southWest: {
+                lat: swLat,
+                lng: swLng
+            }
+        };
+    }
+    function insideBoundingBoxToBoundingBox(value) {
+        if (Array.isArray(value)) {
+            return insideBoundingBoxArrayToBoundingBox(value);
+        }
+        return insideBoundingBoxStringToBoundingBox(value);
+    }
+
+    function getAlgoliaAgent(client) {
+        var clientTyped = client;
+        return clientTyped.transporter && clientTyped.transporter.userAgent ? clientTyped.transporter.userAgent.value : clientTyped._ua;
+    }
+
+    // typed as any, since it accepts the _real_ js clients, not the interface we otherwise expect
+    function getAppIdAndApiKey(searchClient) {
+        if (searchClient.appId && searchClient.apiKey) {
+            // searchClient v5
+            return [
+                searchClient.appId,
+                searchClient.apiKey
+            ];
+        } else if (searchClient.transporter) {
+            // searchClient v4 or v5
+            var transporter = searchClient.transporter;
+            var headers = transporter.headers || transporter.baseHeaders;
+            var queryParameters = transporter.queryParameters || transporter.baseQueryParameters;
+            var APP_ID = 'x-algolia-application-id';
+            var API_KEY = 'x-algolia-api-key';
+            var appId = headers[APP_ID] || queryParameters[APP_ID];
+            var apiKey = headers[API_KEY] || queryParameters[API_KEY];
+            return [
+                appId,
+                apiKey
+            ];
+        } else {
+            // searchClient v3
+            return [
+                searchClient.applicationID,
+                searchClient.apiKey
+            ];
+        }
+    }
+
+    function getHighlightedParts(highlightedValue) {
+        // @MAJOR: this should use TAG_PLACEHOLDER
+        var highlightPostTag = TAG_REPLACEMENT.highlightPostTag, highlightPreTag = TAG_REPLACEMENT.highlightPreTag;
+        var splitByPreTag = highlightedValue.split(highlightPreTag);
+        var firstValue = splitByPreTag.shift();
+        var elements = !firstValue ? [] : [
+            {
+                value: firstValue,
+                isHighlighted: false
+            }
+        ];
+        splitByPreTag.forEach(function(split) {
+            var splitByPostTag = split.split(highlightPostTag);
+            elements.push({
+                value: splitByPostTag[0],
+                isHighlighted: true
+            });
+            if (splitByPostTag[1] !== '') {
+                elements.push({
+                    value: splitByPostTag[1],
+                    isHighlighted: false
+                });
+            }
+        });
+        return elements;
+    }
+
+    var hasAlphanumeric = new RegExp(/\w/i);
+    function getHighlightFromSiblings(parts, i) {
+        var _parts_, _parts_1;
+        var current = parts[i];
+        var isNextHighlighted = ((_parts_ = parts[i + 1]) === null || _parts_ === void 0 ? void 0 : _parts_.isHighlighted) || true;
+        var isPreviousHighlighted = ((_parts_1 = parts[i - 1]) === null || _parts_1 === void 0 ? void 0 : _parts_1.isHighlighted) || true;
+        if (!hasAlphanumeric.test(unescape$1(current.value)) && isPreviousHighlighted === isNextHighlighted) {
+            return isPreviousHighlighted;
+        }
+        return current.isHighlighted;
+    }
+
+    function getPropertyByPath(object, path) {
+        var parts = Array.isArray(path) ? path : path.split('.');
+        return parts.reduce(function(current, key) {
+            return current && current[key];
+        }, object);
+    }
+
+    function getRefinement(state, type, attribute, name) {
+        var resultsFacets = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : [];
+        var res = {
+            type: type,
+            attribute: attribute,
+            name: name,
+            escapedValue: escapeFacetValue(name)
+        };
+        var facet = find$1(resultsFacets, function(resultsFacet) {
+            return resultsFacet.name === attribute;
+        });
+        var count;
+        if (type === 'hierarchical') {
+            var _loop = function _loop(i) {
+                facet = facet && facet.data && find$1(Object.keys(facet.data).map(getFacetRefinement(facet.data)), function(refinement) {
+                    return refinement.name === nameParts[i];
+                });
+            };
+            var facetDeclaration = state.getHierarchicalFacetByName(attribute);
+            var nameParts = name.split(facetDeclaration.separator);
+            var getFacetRefinement = function getFacetRefinement(facetData) {
+                return function(refinementKey) {
+                    return facetData[refinementKey];
+                };
+            };
+            for(var i = 0; facet !== undefined && i < nameParts.length; ++i)_loop(i);
+            count = facet && facet.count;
+        } else {
+            count = facet && facet.data && facet.data[res.name];
+        }
+        if (count !== undefined) {
+            res.count = count;
+        }
+        if (facet && facet.exhaustive !== undefined) {
+            res.exhaustive = facet.exhaustive;
+        }
+        return res;
+    }
+    function getRefinements(_results, state) {
+        var includesQuery = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+        var results = _results || {};
+        var refinements = [];
+        var _state_facetsRefinements = state.facetsRefinements, facetsRefinements = _state_facetsRefinements === void 0 ? {} : _state_facetsRefinements, _state_facetsExcludes = state.facetsExcludes, facetsExcludes = _state_facetsExcludes === void 0 ? {} : _state_facetsExcludes, _state_disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements, disjunctiveFacetsRefinements = _state_disjunctiveFacetsRefinements === void 0 ? {} : _state_disjunctiveFacetsRefinements, _state_hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements, hierarchicalFacetsRefinements = _state_hierarchicalFacetsRefinements === void 0 ? {} : _state_hierarchicalFacetsRefinements, _state_numericRefinements = state.numericRefinements, numericRefinements = _state_numericRefinements === void 0 ? {} : _state_numericRefinements, _state_tagRefinements = state.tagRefinements, tagRefinements = _state_tagRefinements === void 0 ? [] : _state_tagRefinements;
+        Object.keys(facetsRefinements).forEach(function(attribute) {
+            var refinementNames = facetsRefinements[attribute];
+            refinementNames.forEach(function(refinementName) {
+                refinements.push(getRefinement(state, 'facet', attribute, refinementName, results.facets));
+            });
+        });
+        Object.keys(facetsExcludes).forEach(function(attribute) {
+            var refinementNames = facetsExcludes[attribute];
+            refinementNames.forEach(function(refinementName) {
+                refinements.push({
+                    type: 'exclude',
+                    attribute: attribute,
+                    name: refinementName,
+                    exclude: true
+                });
+            });
+        });
+        Object.keys(disjunctiveFacetsRefinements).forEach(function(attribute) {
+            var refinementNames = disjunctiveFacetsRefinements[attribute];
+            refinementNames.forEach(function(refinementName) {
+                refinements.push(getRefinement(state, 'disjunctive', attribute, // they can be escaped on negative numeric values with `escapeFacetValue`.
+                unescapeFacetValue(refinementName), results.disjunctiveFacets));
+            });
+        });
+        Object.keys(hierarchicalFacetsRefinements).forEach(function(attribute) {
+            var refinementNames = hierarchicalFacetsRefinements[attribute];
+            refinementNames.forEach(function(refinement) {
+                refinements.push(getRefinement(state, 'hierarchical', attribute, refinement, results.hierarchicalFacets));
+            });
+        });
+        Object.keys(numericRefinements).forEach(function(attribute) {
+            var operators = numericRefinements[attribute];
+            Object.keys(operators).forEach(function(operatorOriginal) {
+                var operator = operatorOriginal;
+                var valueOrValues = operators[operator];
+                var refinementNames = Array.isArray(valueOrValues) ? valueOrValues : [
+                    valueOrValues
+                ];
+                refinementNames.forEach(function(refinementName) {
+                    refinements.push({
+                        type: 'numeric',
+                        attribute: attribute,
+                        name: "".concat(refinementName),
+                        numericValue: refinementName,
+                        operator: operator
+                    });
+                });
+            });
+        });
+        tagRefinements.forEach(function(refinementName) {
+            refinements.push({
+                type: 'tag',
+                attribute: '_tags',
+                name: refinementName
+            });
+        });
+        if (includesQuery && state.query && state.query.trim()) {
+            refinements.push({
+                attribute: 'query',
+                type: 'query',
+                name: state.query,
+                query: state.query
+            });
+        }
+        return refinements;
+    }
+
+    function getWidgetAttribute$1(widget, initOptions) {
+        var _widget_getWidgetRenderState;
+        var renderState = (_widget_getWidgetRenderState = widget.getWidgetRenderState) === null || _widget_getWidgetRenderState === void 0 ? void 0 : _widget_getWidgetRenderState.call(widget, initOptions);
+        var attribute = null;
+        if (renderState && renderState.widgetParams) {
+            // casting as widgetParams is checked just before
+            var widgetParams = renderState.widgetParams;
+            if (widgetParams.attribute) {
+                attribute = widgetParams.attribute;
+            } else if (Array.isArray(widgetParams.attributes)) {
+                attribute = widgetParams.attributes[0];
+            }
+        }
+        if (typeof attribute !== 'string') {
+            throw new Error("Could not find the attribute of the widget:\n\n".concat(JSON.stringify(widget), "\n\nPlease check whether the widget's getWidgetRenderState returns widgetParams.attribute correctly."));
+        }
+        return attribute;
+    }
+
+    function addAbsolutePosition(hits, page, hitsPerPage) {
+        return hits.map(function(hit, idx) {
+            return _object_spread_props(_object_spread({}, hit), {
+                __position: hitsPerPage * page + idx + 1
+            });
+        });
+    }
+
+    function addQueryID(hits, queryID) {
+        if (!queryID) {
+            return hits;
+        }
+        return hits.map(function(hit) {
+            return _object_spread_props(_object_spread({}, hit), {
+                __queryID: queryID
+            });
+        });
+    }
+
+    function hydrateRecommendCache(helper, initialResults) {
+        var recommendCache = Object.keys(initialResults).reduce(function(acc, indexName) {
+            var initialResult = initialResults[indexName];
+            if (initialResult.recommendResults) {
+                // @MAJOR: Use `Object.assign` instead of spread operator
+                return _object_spread({}, acc, initialResult.recommendResults.results);
+            }
+            return acc;
+        }, {});
+        helper._recommendCache = recommendCache;
+    }
+
+    function getServerResults(entry) {
+        var _entry_compositionFeedsResults;
+        return ((_entry_compositionFeedsResults = entry.compositionFeedsResults) === null || _entry_compositionFeedsResults === void 0 ? void 0 : _entry_compositionFeedsResults.length) ? entry.compositionFeedsResults : entry.results || [];
+    }
+    function hydrateSearchClient(client, results) {
+        if (!results) {
+            return;
+        }
+        // Disable cache hydration on:
+        // - Algoliasearch API Client < v4 with cache disabled
+        // - Third party clients (detected by the `addAlgoliaAgent` function missing)
+        if ((!('transporter' in client) || client._cacheHydrated) && (!client._useCache || typeof client.addAlgoliaAgent !== 'function')) {
+            return;
+        }
+        var cachedRequest = [
+            Object.keys(results).reduce(function(acc, key) {
+                var entry = results[key];
+                var state = entry.state, requestParams = entry.requestParams;
+                var serverResults = getServerResults(entry);
+                var mappedResults = serverResults && state ? serverResults.map(function(result, idx) {
+                    return _object_spread({
+                        indexName: state.index || result.index
+                    }, (requestParams === null || requestParams === void 0 ? void 0 : requestParams[idx]) || result.params ? {
+                        params: serializeQueryParameters((requestParams === null || requestParams === void 0 ? void 0 : requestParams[idx]) || deserializeQueryParameters(result.params))
+                    } : {});
+                }) : [];
+                return acc.concat(mappedResults);
+            }, [])
+        ];
+        var cachedResults = Object.keys(results).reduce(function(acc, key) {
+            var res = getServerResults(results[key]);
+            if (!res) {
+                return acc;
+            }
+            return acc.concat(res);
+        }, []);
+        // Algoliasearch API Client >= v4
+        // To hydrate the client we need to populate the cache with the data from
+        // the server (done in `hydrateSearchClientWithMultiIndexRequest` or
+        // `hydrateSearchClientWithSingleIndexRequest`). But since there is no way
+        // for us to compute the key the same way as `algoliasearch-client` we need
+        // to populate it on a custom key and override the `search` method to
+        // search on it first.
+        if ('transporter' in client && !client._cacheHydrated) {
+            client._cacheHydrated = true;
+            var baseMethod = client.search.bind(client);
+            client.search = function(requests) {
+                for(var _len = arguments.length, methodArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                    methodArgs[_key - 1] = arguments[_key];
+                }
+                var requestsWithSerializedParams = Array.isArray(requests) ? requests.map(function(request) {
+                    return _object_spread_props(_object_spread({}, request), {
+                        params: serializeQueryParameters(request.params)
+                    });
+                }) : serializeQueryParameters(requests.requestBody.params);
+                return client.transporter.responsesCache.get({
+                    method: 'search',
+                    args: [
+                        requestsWithSerializedParams
+                    ].concat(_to_consumable_array(methodArgs))
+                }, function() {
+                    return baseMethod.apply(void 0, [
+                        requests
+                    ].concat(_to_consumable_array(methodArgs)));
+                });
+            };
+            client.transporter.responsesCache.set({
+                method: 'search',
+                args: cachedRequest
+            }, {
+                results: cachedResults
+            });
+        }
+        // Algoliasearch API Client < v4
+        // Prior to client v4 we didn't have a proper API to hydrate the client
+        // cache from the outside. The following code populates the cache with
+        // a single-index result. You can find more information about the
+        // computation of the key inside the client (see link below).
+        // https://github.com/algolia/algoliasearch-client-javascript/blob/c27e89ff92b2a854ae6f40dc524bffe0f0cbc169/src/AlgoliaSearchCore.js#L232-L240
+        if (!('transporter' in client)) {
+            var cacheKey = "/1/indexes/*/queries_body_".concat(JSON.stringify({
+                requests: cachedRequest
+            }));
+            client.cache = _object_spread_props(_object_spread({}, client.cache), _define_property({}, cacheKey, JSON.stringify({
+                results: Object.keys(results).map(function(key) {
+                    return getServerResults(results[key]);
+                })
+            })));
+        }
+    }
+    function deserializeQueryParameters(parameters) {
+        return parameters.split('&').reduce(function(acc, parameter) {
+            var _parameter_split = _sliced_to_array(parameter.split('='), 2), key = _parameter_split[0], value = _parameter_split[1];
+            acc[key] = value ? decodeURIComponent(value) : '';
+            return acc;
+        }, {});
+    }
+    // This function is copied from the algoliasearch v4 API Client. If modified,
+    // consider updating it also in `serializeQueryParameters` from `@algolia/transporter`.
+    function serializeQueryParameters(parameters) {
+        var isObjectOrArray = function isObjectOrArray(value) {
+            return Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === '[object Array]';
+        };
+        var encode = function encode(format) {
+            for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                args[_key - 1] = arguments[_key];
+            }
+            var i = 0;
+            return format.replace(/%s/g, function() {
+                return encodeURIComponent(args[i++]);
+            });
+        };
+        return Object.keys(parameters).map(function(key) {
+            return encode('%s=%s', key, isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key]);
+        }).join('&');
+    }
+
+    function isPrimitive(obj) {
+        return obj !== Object(obj);
+    }
+    function isEqual(first, second) {
+        if (first === second) {
+            return true;
+        }
+        if (isPrimitive(first) || isPrimitive(second) || typeof first === 'function' || typeof second === 'function') {
+            return first === second;
+        }
+        if (Object.keys(first).length !== Object.keys(second).length) {
+            return false;
+        }
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            // @TODO avoid for..of because of the large polyfill
+            // eslint-disable-next-line instantsearch/no-for-of
+            for(var _iterator = Object.keys(first)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                if (!(key in second)) {
+                    return false;
+                }
+                if (!isEqual(first[key], second[key])) {
+                    return false;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return true;
+    }
+
+    // This is the `Number.isFinite()` polyfill recommended by MDN.
+    // We do not provide any tests for this function.
+    // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill
+    // @MAJOR Replace with the native `Number.isFinite` method
+    function isFiniteNumber(value) {
+        return typeof value === 'number' && isFinite(value);
+    }
+
+    /**
+     * Recurse over all child indices
+     */ function walkIndex(indexWidget, callback) {
+        callback(indexWidget);
+        indexWidget.getWidgets().forEach(function(widget) {
+            if (isIndexWidget(widget)) {
+                walkIndex(widget, callback);
+            }
+        });
+    }
+
+    /**
+     * Returns true if the widget requires a second SSR pass to discover and
+     * mount child widgets (e.g. DynamicWidgets, Feeds).
+     */ function isTwoPassWidget(widget) {
+        return widget.$$type === 'ais.dynamicWidgets' || widget.$$type === 'ais.feeds';
+    }
+
+    /**
+     * Logs a warning
+     * This is used to log issues in development environment only.
+     */ var warn = noop;
+
+    function range(param) {
+        var _param_start = param.start, start = _param_start === void 0 ? 0 : _param_start, end = param.end, _param_step = param.step, step = _param_step === void 0 ? 1 : _param_step;
+        // We can't divide by 0 so we re-assign the step to 1 if it happens.
+        var limitStep = step === 0 ? 1 : step;
+        // In some cases the array to create has a decimal length.
+        // We therefore need to round the value.
+        // Example:
+        //   { start: 1, end: 5000, step: 500 }
+        //   => Array length = (5000 - 1) / 500 = 9.998
+        var arrayLength = Math.round((end - start) / limitStep);
+        return _to_consumable_array(Array(arrayLength)).map(function(_, current) {
+            return start + current * limitStep;
+        });
+    }
+
+    function createInitArgs(instantSearchInstance, parent, uiState) {
+        var helper = parent.getHelper();
+        return {
+            uiState: uiState,
+            helper: helper,
+            parent: parent,
+            instantSearchInstance: instantSearchInstance,
+            state: helper.state,
+            renderState: instantSearchInstance.renderState,
+            templatesConfig: instantSearchInstance.templatesConfig,
+            createURL: parent.createURL,
+            scopedResults: [],
+            searchMetadata: {
+                isSearchStalled: instantSearchInstance.status === 'stalled'
+            },
+            status: instantSearchInstance.status,
+            error: instantSearchInstance.error
+        };
+    }
+    function createRenderArgs(instantSearchInstance, parent, widget) {
+        var results = parent.getResultsForWidget(widget);
+        var helper = parent.getHelper();
+        return {
+            helper: helper,
+            parent: parent,
+            instantSearchInstance: instantSearchInstance,
+            results: results,
+            scopedResults: parent.getScopedResults(),
+            state: results && '_state' in results ? results._state : helper.state,
+            renderState: instantSearchInstance.renderState,
+            templatesConfig: instantSearchInstance.templatesConfig,
+            createURL: parent.createURL,
+            searchMetadata: {
+                isSearchStalled: instantSearchInstance.status === 'stalled'
+            },
+            status: instantSearchInstance.status,
+            error: instantSearchInstance.error
+        };
+    }
+    function storeRenderState(param) {
+        var renderState = param.renderState, instantSearchInstance = param.instantSearchInstance, parent = param.parent;
+        var parentIndexName = parent ? parent.getIndexId() : instantSearchInstance.mainIndex.getIndexId();
+        instantSearchInstance.renderState = _object_spread_props(_object_spread({}, instantSearchInstance.renderState), _define_property({}, parentIndexName, _object_spread({}, instantSearchInstance.renderState[parentIndexName], renderState)));
+    }
+
+    function resolveSearchParameters(current) {
+        var parent = current.getParent();
+        var states = [
+            current.getHelper().state
+        ];
+        while(parent !== null){
+            states = [
+                parent.getHelper().state
+            ].concat(states);
+            parent = parent.getParent();
+        }
+        return states;
+    }
+
+    function reverseHighlightedParts(parts) {
+        if (!parts.some(function(part) {
+            return part.isHighlighted;
+        })) {
+            return parts.map(function(part) {
+                return _object_spread_props(_object_spread({}, part), {
+                    isHighlighted: false
+                });
+            });
+        }
+        return parts.map(function(part, i) {
+            return _object_spread_props(_object_spread({}, part), {
+                isHighlighted: !getHighlightFromSiblings(parts, i)
+            });
+        });
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    /**
+     * Runs code on browser environments safely.
+     */ function safelyRunOnBrowser(callback) {
+        var fallback = (arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+            fallback: function fallback() {
+                return undefined;
+            }
+        }).fallback;
+        // eslint-disable-next-line no-restricted-globals
+        if (typeof window === 'undefined') {
+            return fallback();
+        }
+        // eslint-disable-next-line no-restricted-globals
+        return callback({
+            window: window
+        });
+    }
+
+    function toArray(value) {
+        return Array.isArray(value) ? value : [
+            value
+        ];
+    }
+
+    var useKey = 'use';
+    // @TODO: Remove this file and import directly from React when available.
+    var use = React__namespace[useKey];
+
+    /**
+     * `useLayoutEffect` that doesn't show a warning when server-side rendering.
+     *
+     * It uses `useEffect` on the server (no-op), and `useLayoutEffect` on the browser.
+     */ var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;
+
+    var InstantSearchRSCContext = /*#__PURE__*/ React.createContext({
+        countRef: {
+            current: 0
+        },
+        waitForResultsRef: null,
+        ignoreMultipleHooksWarning: false
+    });
+
+    function useRSCContext() {
+        return React.useContext(InstantSearchRSCContext);
+    }
+
+    function useWidget(param) {
+        var widget = param.widget, parentIndex = param.parentIndex, props = param.props, shouldSsr = param.shouldSsr, skipSuspense = param.skipSuspense;
+        var _waitForResultsRef_current, _waitForResultsRef_current1;
+        var _useRSCContext = useRSCContext(), waitForResultsRef = _useRSCContext.waitForResultsRef, countRef = _useRSCContext.countRef;
+        _useRSCContext.ignoreMultipleHooksWarning;
+        var prevPropsRef = React.useRef(props);
+        React.useEffect(function() {
+            prevPropsRef.current = props;
+        }, [
+            props
+        ]);
+        var prevWidgetRef = React.useRef(widget);
+        React.useEffect(function() {
+            prevWidgetRef.current = widget;
+        }, [
+            widget
+        ]);
+        var cleanupTimerRef = React.useRef(null);
+        var shouldAddWidgetEarly = shouldSsr && !parentIndex.getWidgets().includes(widget);
+        var search = useInstantSearchContext();
+        // This effect is responsible for adding, removing, and updating the widget.
+        // We need to support scenarios where the widget is remounted quickly, like in
+        // Strict Mode, so that we don't lose its state, and therefore that we don't
+        // break routing.
+        useIsomorphicLayoutEffect(function() {
+            var previousWidget = prevWidgetRef.current;
+            // Scenario 1: the widget is added for the first time.
+            if (!cleanupTimerRef.current) {
+                if (!shouldSsr) {
+                    parentIndex.addWidgets([
+                        widget
+                    ]);
+                }
+            } else {
+                // We cancel the original effect cleanup because it may not be necessary if
+                // props haven't changed. (We manually call it if it is below.)
+                clearTimeout(cleanupTimerRef.current);
+                // Warning: if an unstable function prop is provided, `dequal` is not able
+                // to keep its reference and therefore will consider that props did change.
+                // This could unsollicitely remove/add the widget, therefore forget its state,
+                // and could be a source of confusion.
+                // If users face this issue, we should advise them to provide stable function
+                // references.
+                var arePropsEqual = dequal(props, prevPropsRef.current);
+                // If props did change, then we execute the cleanup function instantly
+                // and then add the widget back. This lets us add the widget without
+                // waiting for the scheduled cleanup function to finish (that we canceled
+                // above).
+                if (!arePropsEqual) {
+                    parentIndex.removeWidgets([
+                        previousWidget
+                    ]);
+                    parentIndex.addWidgets([
+                        widget
+                    ]);
+                }
+            }
+            return function() {
+                // We don't remove the widget right away, but rather schedule it so that
+                // we're able to cancel it in the next effect.
+                cleanupTimerRef.current = setTimeout(function() {
+                    search._schedule(function() {
+                        if (search._preventWidgetCleanup) return;
+                        parentIndex.removeWidgets([
+                            previousWidget
+                        ]);
+                    });
+                });
+            };
+        }, [
+            parentIndex,
+            widget,
+            shouldSsr,
+            search,
+            props
+        ]);
+        if (shouldAddWidgetEarly || (waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : (_waitForResultsRef_current = waitForResultsRef.current) === null || _waitForResultsRef_current === void 0 ? void 0 : _waitForResultsRef_current.status) === 'pending') {
+            parentIndex.addWidgets([
+                widget
+            ]);
+        }
+        if ((waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : waitForResultsRef.current) && !skipSuspense) {
+            var _search_helper;
+            use(waitForResultsRef.current);
+            // If we made a second request because of two-pass widgets, we need to
+            // wait for the second result — except for the two-pass widgets themselves
+            // which need to render their children after the first result.
+            if (!isTwoPassWidget(widget) && ((_search_helper = search.helper) === null || _search_helper === void 0 ? void 0 : _search_helper.lastResults)) {
+                use(waitForResultsRef.current);
+            }
+        }
+        if ((waitForResultsRef === null || waitForResultsRef === void 0 ? void 0 : (_waitForResultsRef_current1 = waitForResultsRef.current) === null || _waitForResultsRef_current1 === void 0 ? void 0 : _waitForResultsRef_current1.status) === 'fulfilled') {
+            countRef.current += 1;
+        }
+    }
+
+    function useConnector(connector) {
+        var _1 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0, _2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : void 0;
+        var _ref = [
+            _1,
+            _2
+        ], _ref1 = _to_array(_ref), tmp = _ref1[0], props = tmp === void 0 ? {} : tmp, _rest = _ref1.slice(1), _rest1 = _sliced_to_array(_rest, 1), tmp1 = _rest1[0], _ref2 = tmp1 === void 0 ? {} : tmp1, _ref_skipSuspense = _ref2.skipSuspense, skipSuspense = _ref_skipSuspense === void 0 ? false : _ref_skipSuspense, additionalWidgetProperties = _object_without_properties(_ref2, [
+            "skipSuspense"
+        ]);
         var serverContext = useInstantSearchServerContext();
         var ssrContext = useInstantSearchSSRContext();
         var search = useInstantSearchContext();
@@ -6490,49 +7613,20 @@
         }, additionalWidgetProperties);
     }
 
-    function Configure(props) {
-        useConfigure(_object_spread({}, props), {
-            $$widgetType: 'ais.configure'
-        });
-        return null;
-    }
-
-    function getWidgetAttribute$1(widget, initOptions) {
-        var _widget_getWidgetRenderState;
-        var renderState = (_widget_getWidgetRenderState = widget.getWidgetRenderState) === null || _widget_getWidgetRenderState === void 0 ? void 0 : _widget_getWidgetRenderState.call(widget, initOptions);
-        var attribute = null;
-        if (renderState && renderState.widgetParams) {
-            // casting as widgetParams is checked just before
-            var widgetParams = renderState.widgetParams;
-            if (widgetParams.attribute) {
-                attribute = widgetParams.attribute;
-            } else if (Array.isArray(widgetParams.attributes)) {
-                attribute = widgetParams.attributes[0];
-            }
-        }
-        if (typeof attribute !== 'string') {
-            throw new Error("Could not find the attribute of the widget:\n\n".concat(JSON.stringify(widget), "\n\nPlease check whether the widget's getWidgetRenderState returns widgetParams.attribute correctly."));
-        }
-        return attribute;
-    }
-
-    function getObjectType(object) {
-        return Object.prototype.toString.call(object).slice(8, -1);
-    }
-
-    function checkRendering(rendering, usage) {
-        if (rendering === undefined || typeof rendering !== 'function') {
-            throw new Error("The render function is not valid (received type ".concat(getObjectType(rendering), ").\n\n").concat(usage));
-        }
+    function Configure(props) {
+        useConfigure(_object_spread({}, props), {
+            $$widgetType: 'ais.configure'
+        });
+        return null;
     }
 
-    var withUsage$s = createDocumentationMessageGenerator({
+    var withUsage$t = createDocumentationMessageGenerator({
         name: 'dynamic-widgets',
         connector: true
     });
     var connectDynamicWidgets = function connectDynamicWidgets(renderFn) {
         var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
-        checkRendering(renderFn, withUsage$s());
+        checkRendering(renderFn, withUsage$t());
         return function(widgetParams) {
             var widgets = widgetParams.widgets, _widgetParams_maxValuesPerFacet = widgetParams.maxValuesPerFacet, maxValuesPerFacet = _widgetParams_maxValuesPerFacet === void 0 ? 20 : _widgetParams_maxValuesPerFacet, _widgetParams_facets = widgetParams.facets, facets = _widgetParams_facets === void 0 ? [
                 '*'
@@ -6542,10 +7636,10 @@
             if (!(widgets && Array.isArray(widgets) && widgets.every(function(widget) {
                 return (typeof widget === "undefined" ? "undefined" : _type_of(widget)) === 'object';
             }))) {
-                throw new Error(withUsage$s('The `widgets` option expects an array of widgets.'));
+                throw new Error(withUsage$t('The `widgets` option expects an array of widgets.'));
             }
             if (!Array.isArray(facets)) {
-                throw new Error(withUsage$s("The `facets` option only accepts an array of facets, you passed ".concat(JSON.stringify(facets))));
+                throw new Error(withUsage$t("The `facets` option only accepts an array of facets, you passed ".concat(JSON.stringify(facets))));
             }
             var localWidgets = new Map();
             return {
@@ -6621,36 +7715,428 @@
                     unmountFn();
                 },
                 getWidgetSearchParameters: function getWidgetSearchParameters(state) {
-                    return facets.reduce(function(acc, curr) {
-                        return acc.addFacet(curr);
-                    }, state.setQueryParameters({
-                        maxValuesPerFacet: Math.max(maxValuesPerFacet || 0, state.maxValuesPerFacet || 0)
-                    }));
+                    return facets.reduce(function(acc, curr) {
+                        return acc.addFacet(curr);
+                    }, state.setQueryParameters({
+                        maxValuesPerFacet: Math.max(maxValuesPerFacet || 0, state.maxValuesPerFacet || 0)
+                    }));
+                },
+                getRenderState: function getRenderState(renderState, renderOptions) {
+                    return _object_spread_props(_object_spread({}, renderState), {
+                        dynamicWidgets: this.getWidgetRenderState(renderOptions)
+                    });
+                },
+                getWidgetRenderState: function getWidgetRenderState(param) {
+                    var results = param.results;
+                    param.state;
+                    var _ref;
+                    var _results_renderingContent_facetOrdering_facets, _results_renderingContent_facetOrdering, _results_renderingContent;
+                    if (!results) {
+                        return {
+                            attributesToRender: [],
+                            widgetParams: widgetParams
+                        };
+                    }
+                    var attributesToRender = transformItems((_ref = (_results_renderingContent = results.renderingContent) === null || _results_renderingContent === void 0 ? void 0 : (_results_renderingContent_facetOrdering = _results_renderingContent.facetOrdering) === null || _results_renderingContent_facetOrdering === void 0 ? void 0 : (_results_renderingContent_facetOrdering_facets = _results_renderingContent_facetOrdering.facets) === null || _results_renderingContent_facetOrdering_facets === void 0 ? void 0 : _results_renderingContent_facetOrdering_facets.order) !== null && _ref !== void 0 ? _ref : [], {
+                        results: results
+                    });
+                    if (!Array.isArray(attributesToRender)) {
+                        throw new Error(withUsage$t('The `transformItems` option expects a function that returns an Array.'));
+                    }
+                    return {
+                        attributesToRender: attributesToRender,
+                        widgetParams: widgetParams
+                    };
+                }
+            };
+        };
+    };
+
+    function useDynamicWidgets(props, additionalWidgetProperties) {
+        return useConnector(connectDynamicWidgets, _object_spread_props(_object_spread({}, props), {
+            // We don't rely on InstantSearch.js for rendering widgets because React
+            // directly manipulates the children.
+            widgets: []
+        }), additionalWidgetProperties);
+    }
+
+    function DefaultFallbackComponent() {
+        return null;
+    }
+    function DynamicWidgets(_0) {
+        var children = _0.children, tmp = _0.fallbackComponent, Fallback = tmp === void 0 ? DefaultFallbackComponent : tmp, props = _object_without_properties(_0, [
+            "children",
+            "fallbackComponent"
+        ]);
+        var FallbackComponent = React.useRef(Fallback);
+        var attributesToRender = useDynamicWidgets(props, {
+            $$widgetType: 'ais.dynamicWidgets'
+        }).attributesToRender;
+        var widgets = new Map();
+        React.Children.forEach(children, function(child) {
+            var attribute = getWidgetAttribute(child);
+            invariant(attribute !== undefined);
+            widgets.set(attribute, child);
+        });
+        return /*#__PURE__*/ React.createElement(React.Fragment, null, attributesToRender.map(function(attribute) {
+            return /*#__PURE__*/ React.createElement(React.Fragment, {
+                key: attribute
+            }, widgets.get(attribute) || /*#__PURE__*/ React.createElement(FallbackComponent.current, {
+                attribute: attribute
+            }));
+        }));
+    }
+    function isReactElement(element) {
+        return (typeof element === "undefined" ? "undefined" : _type_of(element)) === 'object' && element.props;
+    }
+    function getWidgetAttribute(element) {
+        if (!isReactElement(element)) {
+            return undefined;
+        }
+        if (element.props.attribute) {
+            return element.props.attribute;
+        }
+        if (Array.isArray(element.props.attributes)) {
+            return element.props.attributes[0];
+        }
+        if (element.props.children) {
+            invariant(React.Children.count(element.props.children) === 1);
+            return getWidgetAttribute(React.Children.only(element.props.children));
+        }
+        return undefined;
+    }
+
+    function createFeedContainer(feedID, parentIndex, instantSearchInstance) {
+        var localWidgets = [];
+        var initialized = false;
+        var container = {
+            $$type: 'ais.feedContainer',
+            $$widgetType: 'ais.feedContainer',
+            _isolated: true,
+            getIndexName: function getIndexName() {
+                return parentIndex.getIndexName();
+            },
+            getIndexId: function getIndexId() {
+                return feedID;
+            },
+            getHelper: function getHelper() {
+                return parentIndex.getHelper();
+            },
+            getResults: function getResults() {
+                var parentResults = parentIndex.getResults();
+                if (!parentResults) return null;
+                if (!parentResults.feeds) {
+                    // Single-feed backward compat: no feeds array means the parent result
+                    // itself is the only feed.
+                    if (feedID === '') {
+                        parentResults._state = parentIndex.getHelper().state;
+                        return parentResults;
+                    }
+                    return null;
+                }
+                var feed = parentResults.feeds.find(function(f) {
+                    return f.feedID === feedID;
+                });
+                if (!feed) return null;
+                // Optimistic state patching — same as index widget (index.ts:365-370)
+                feed._state = parentIndex.getHelper().state;
+                return feed;
+            },
+            getResultsForWidget: function getResultsForWidget() {
+                return this.getResults();
+            },
+            getParent: function getParent() {
+                return parentIndex;
+            },
+            getWidgets: function getWidgets() {
+                return localWidgets;
+            },
+            getScopedResults: function getScopedResults() {
+                return parentIndex.getScopedResults();
+            },
+            getPreviousState: function getPreviousState() {
+                return null;
+            },
+            createURL: function createURL(nextState) {
+                return parentIndex.createURL(nextState);
+            },
+            scheduleLocalSearch: function scheduleLocalSearch() {
+                return parentIndex.scheduleLocalSearch();
+            },
+            addWidgets: function addWidgets(widgets) {
+                var flatWidgets = widgets.reduce(function(acc, w) {
+                    return acc.concat(Array.isArray(w) ? w : [
+                        w
+                    ]);
+                }, []);
+                flatWidgets.forEach(function(widget) {
+                    widget.parent = container;
+                });
+                localWidgets = localWidgets.concat(flatWidgets);
+                if (initialized) {
+                    flatWidgets.forEach(function(widget) {
+                        if (widget.getRenderState) {
+                            var renderState = widget.getRenderState(instantSearchInstance.renderState[container.getIndexId()] || {}, createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
+                            storeRenderState({
+                                renderState: renderState,
+                                instantSearchInstance: instantSearchInstance,
+                                parent: container
+                            });
+                        }
+                    });
+                    flatWidgets.forEach(function(widget) {
+                        if (widget.init) {
+                            widget.init(createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
+                        }
+                    });
+                    // Merge children's search params (e.g. disjunctiveFacets) into the
+                    // parent's helper state so they're included in the composition request.
+                    // uiState is {} because URL-derived refinements are already on the
+                    // parent state; children only need to declare structural params.
+                    var parentHelper = parentIndex.getHelper();
+                    var withChildParams = container.getWidgetSearchParameters(parentHelper.state, {
+                        uiState: {}
+                    });
+                    if (withChildParams !== parentHelper.state) {
+                        parentHelper.setState(withChildParams);
+                    }
+                }
+                return container;
+            },
+            removeWidgets: function removeWidgets(widgets) {
+                var flatWidgets = widgets.reduce(function(acc, w) {
+                    return acc.concat(Array.isArray(w) ? w : [
+                        w
+                    ]);
+                }, []);
+                var helper = parentIndex.getHelper();
+                if (!helper) {
+                    localWidgets = localWidgets.filter(function(w) {
+                        return !flatWidgets.includes(w);
+                    });
+                    return container;
+                }
+                // Chain through children's dispose so widgets clean up the
+                // SearchParameters they declared (e.g. RefinementList removes its
+                // disjunctiveFacet) instead of leaving them stale on the parent helper.
+                var cleanedState = helper.state;
+                flatWidgets.forEach(function(widget) {
+                    if (widget.dispose) {
+                        var next = widget.dispose({
+                            helper: helper,
+                            state: cleanedState,
+                            recommendState: helper.recommendState,
+                            parent: container
+                        });
+                        if (_instanceof(next, algoliasearchHelper.RecommendParameters)) ;
+                        else if (next) {
+                            cleanedState = next;
+                        }
+                    }
+                });
+                localWidgets = localWidgets.filter(function(w) {
+                    return !flatWidgets.includes(w);
+                });
+                if (cleanedState !== helper.state) {
+                    helper.setState(cleanedState);
+                }
+                return container;
+            },
+            init: function init() {
+                initialized = true;
+                localWidgets.forEach(function(widget) {
+                    if (widget.getRenderState) {
+                        var renderState = widget.getRenderState(instantSearchInstance.renderState[container.getIndexId()] || {}, createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
+                        storeRenderState({
+                            renderState: renderState,
+                            instantSearchInstance: instantSearchInstance,
+                            parent: container
+                        });
+                    }
+                });
+                localWidgets.forEach(function(widget) {
+                    if (widget.init) {
+                        widget.init(createInitArgs(instantSearchInstance, container, instantSearchInstance._initialUiState));
+                    }
+                });
+            },
+            render: function render() {
+                localWidgets.forEach(function(widget) {
+                    if (widget.getRenderState) {
+                        var renderState = widget.getRenderState(instantSearchInstance.renderState[container.getIndexId()] || {}, createRenderArgs(instantSearchInstance, container, widget));
+                        storeRenderState({
+                            renderState: renderState,
+                            instantSearchInstance: instantSearchInstance,
+                            parent: container
+                        });
+                    }
+                });
+                localWidgets.forEach(function(widget) {
+                    if (widget.render) {
+                        widget.render(createRenderArgs(instantSearchInstance, container, widget));
+                    }
+                });
+            },
+            dispose: function dispose(disposeOptions) {
+                var _ref;
+                var helper = parentIndex.getHelper();
+                // Chain through children's dispose to return a cleaned state
+                // (e.g. RefinementList.dispose removes its disjunctiveFacet declaration).
+                // This mirrors how the index widget's removeWidgets chains dispose calls.
+                var cleanedState = (_ref = disposeOptions === null || disposeOptions === void 0 ? void 0 : disposeOptions.state) !== null && _ref !== void 0 ? _ref : helper === null || helper === void 0 ? void 0 : helper.state;
+                localWidgets.forEach(function(widget) {
+                    if (widget.dispose && helper) {
+                        var next = widget.dispose({
+                            helper: helper,
+                            state: cleanedState,
+                            recommendState: helper.recommendState,
+                            parent: container
+                        });
+                        if (_instanceof(next, algoliasearchHelper.RecommendParameters)) ;
+                        else if (next) {
+                            cleanedState = next;
+                        }
+                    }
+                });
+                localWidgets = [];
+                initialized = false;
+                return cleanedState;
+            },
+            getWidgetState: function getWidgetState(uiState) {
+                return this.getWidgetUiState(uiState);
+            },
+            getWidgetUiState: function getWidgetUiState(uiState) {
+                var helper = parentIndex.getHelper();
+                var widgetUiStateOptions = {
+                    searchParameters: helper.state,
+                    helper: helper
+                };
+                return localWidgets.reduce(function(state, widget) {
+                    return widget.getWidgetUiState ? widget.getWidgetUiState(state, widgetUiStateOptions) : state;
+                }, uiState);
+            },
+            getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
+                var uiState = param.uiState;
+                return localWidgets.reduce(function(params, widget) {
+                    return widget.getWidgetSearchParameters ? widget.getWidgetSearchParameters(params, {
+                        uiState: uiState
+                    }) : params;
+                }, searchParameters);
+            },
+            refreshUiState: function refreshUiState() {
+            // no-op: FeedContainer doesn't own UI state
+            },
+            setIndexUiState: function setIndexUiState() {
+            // no-op: FeedContainer delegates to parent
+            }
+        };
+        return container;
+    }
+
+    function toFeedSearchResults(state, raw) {
+        return Object.assign(new algoliasearchHelper.SearchResults(state, [
+            raw
+        ]), {
+            feedID: raw.feedID
+        });
+    }
+    /**
+     * Rebuild `lastResults.feeds` from `_initialResults.compositionFeedsResults`
+     * because the index-widget hydration only restores `lastResults` (the merged
+     * view), not the per-feed breakdown that the Feeds connector needs.
+     */ function hydrateFeedsFromInitialResultsIfNeeded(instantSearchInstance, parent) {
+        var _instantSearchInstance__initialResults, _parent_getHelper;
+        var initial = (_instantSearchInstance__initialResults = instantSearchInstance._initialResults) === null || _instantSearchInstance__initialResults === void 0 ? void 0 : _instantSearchInstance__initialResults[parent.getIndexId()];
+        var compositionFeedsResults = (initial === null || initial === void 0 ? void 0 : initial.compositionFeedsResults) || [];
+        if (compositionFeedsResults.length === 0) {
+            return;
+        }
+        var lastResults = (_parent_getHelper = parent.getHelper()) === null || _parent_getHelper === void 0 ? void 0 : _parent_getHelper.lastResults;
+        if (!lastResults) {
+            return;
+        }
+        if (lastResults.feeds && lastResults.feeds.length > 0) {
+            return;
+        }
+        lastResults.feeds = compositionFeedsResults.map(function(raw) {
+            return toFeedSearchResults(lastResults._state, raw);
+        });
+    }
+    var withUsage$s = createDocumentationMessageGenerator({
+        name: 'feeds',
+        connector: true
+    });
+    var connectFeeds = function connectFeeds(renderFn) {
+        var unmountFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
+        checkRendering(renderFn, withUsage$s());
+        return function(widgetParams) {
+            var searchScope = widgetParams.searchScope, _widgetParams_transformFeeds = widgetParams.transformFeeds, transformFeeds = _widgetParams_transformFeeds === void 0 ? function(feeds) {
+                return feeds;
+            } : _widgetParams_transformFeeds;
+            if (searchScope !== 'global') {
+                throw new Error(withUsage$s('The `searchScope` option currently only supports "global".'));
+            }
+            return {
+                $$type: 'ais.feeds',
+                $$widgetType: 'ais.feeds',
+                init: function init(initOptions) {
+                    var instantSearchInstance = initOptions.instantSearchInstance;
+                    if (!instantSearchInstance.compositionID) {
+                        throw new Error(withUsage$s('The `feeds` widget requires a composition-based InstantSearch instance (compositionID must be set).'));
+                    }
+                    hydrateFeedsFromInitialResultsIfNeeded(instantSearchInstance, initOptions.parent);
+                    renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(initOptions)), {
+                        instantSearchInstance: instantSearchInstance
+                    }), true);
+                },
+                render: function render(renderOptions) {
+                    var instantSearchInstance = renderOptions.instantSearchInstance;
+                    renderFn(_object_spread_props(_object_spread({}, this.getWidgetRenderState(renderOptions)), {
+                        instantSearchInstance: instantSearchInstance
+                    }), false);
+                },
+                dispose: function dispose() {
+                    unmountFn();
+                },
+                getWidgetSearchParameters: function getWidgetSearchParameters(state) {
+                    return state;
                 },
                 getRenderState: function getRenderState(renderState, renderOptions) {
                     return _object_spread_props(_object_spread({}, renderState), {
-                        dynamicWidgets: this.getWidgetRenderState(renderOptions)
+                        feeds: this.getWidgetRenderState(renderOptions)
                     });
                 },
                 getWidgetRenderState: function getWidgetRenderState(param) {
                     var results = param.results;
-                    param.state;
-                    var _ref;
-                    var _results_renderingContent_facetOrdering_facets, _results_renderingContent_facetOrdering, _results_renderingContent;
                     if (!results) {
                         return {
-                            attributesToRender: [],
+                            feedIDs: [],
                             widgetParams: widgetParams
                         };
                     }
-                    var attributesToRender = transformItems((_ref = (_results_renderingContent = results.renderingContent) === null || _results_renderingContent === void 0 ? void 0 : (_results_renderingContent_facetOrdering = _results_renderingContent.facetOrdering) === null || _results_renderingContent_facetOrdering === void 0 ? void 0 : (_results_renderingContent_facetOrdering_facets = _results_renderingContent_facetOrdering.facets) === null || _results_renderingContent_facetOrdering_facets === void 0 ? void 0 : _results_renderingContent_facetOrdering_facets.order) !== null && _ref !== void 0 ? _ref : [], {
-                        results: results
-                    });
-                    if (!Array.isArray(attributesToRender)) {
-                        throw new Error(withUsage$s('The `transformItems` option expects a function that returns an Array.'));
+                    if (Array.isArray(results.feeds) && results.feeds.length > 0 && !results.feeds.every(function(feed) {
+                        return _instanceof(feed, algoliasearchHelper.SearchResults);
+                    })) {
+                        results.feeds = results.feeds.map(function(feed) {
+                            return _instanceof(feed, algoliasearchHelper.SearchResults) ? feed : toFeedSearchResults(results._state, feed);
+                        });
+                    }
+                    var feedIDs = results.feeds ? results.feeds.map(function(f) {
+                        return f.feedID;
+                    }) : [
+                        ''
+                    ];
+                    feedIDs = transformFeeds(feedIDs);
+                    if (!Array.isArray(feedIDs)) {
+                        throw new Error(withUsage$s('The `transformFeeds` option expects a function that returns an Array.'));
+                    }
+                    if (!feedIDs.every(function(feedID) {
+                        return typeof feedID === 'string';
+                    })) {
+                        throw new Error(withUsage$s('The `transformFeeds` option expects a function that returns an array of feed IDs (strings).'));
                     }
                     return {
-                        attributesToRender: attributesToRender,
+                        feedIDs: feedIDs,
                         widgetParams: widgetParams
                     };
                 }
@@ -6658,174 +8144,104 @@
         };
     };
 
-    function useDynamicWidgets(props, additionalWidgetProperties) {
-        return useConnector(connectDynamicWidgets, _object_spread_props(_object_spread({}, props), {
-            // We don't rely on InstantSearch.js for rendering widgets because React
-            // directly manipulates the children.
-            widgets: []
-        }), additionalWidgetProperties);
+    function useFeeds(props, additionalWidgetProperties) {
+        return useConnector(connectFeeds, props, additionalWidgetProperties);
     }
 
-    function DefaultFallbackComponent() {
-        return null;
-    }
-    function DynamicWidgets(_0) {
-        var children = _0.children, tmp = _0.fallbackComponent, Fallback = tmp === void 0 ? DefaultFallbackComponent : tmp, props = _object_without_properties(_0, [
-            "children",
-            "fallbackComponent"
+    function Feeds(_0) {
+        var renderFeed = _0.renderFeed, props = _object_without_properties(_0, [
+            "renderFeed"
         ]);
-        var FallbackComponent = React.useRef(Fallback);
-        var attributesToRender = useDynamicWidgets(props, {
-            $$widgetType: 'ais.dynamicWidgets'
-        }).attributesToRender;
-        var widgets = new Map();
-        React.Children.forEach(children, function(child) {
-            var attribute = getWidgetAttribute(child);
-            invariant(attribute !== undefined);
-            widgets.set(attribute, child);
+        var feedIDs = useFeeds(props, {
+            $$widgetType: 'ais.feeds'
+        }).feedIDs;
+        var parentIndex = useIndexContext();
+        var instantSearchInstance = useInstantSearchContext();
+        var feedContainersRef = React.useRef(new Map());
+        var removalTimerRef = React.useRef(null);
+        var pendingRemovalsRef = React.useRef(new Map());
+        // Create and register new FeedContainers synchronously so SSR and the first
+        // client render can provide the matching feed index context to children.
+        var toAdd = [];
+        feedIDs.forEach(function(feedID) {
+            if (!feedContainersRef.current.has(feedID)) {
+                var pendingContainer = pendingRemovalsRef.current.get(feedID);
+                if (pendingContainer) {
+                    pendingRemovalsRef.current.delete(feedID);
+                    feedContainersRef.current.set(feedID, pendingContainer);
+                    return;
+                }
+                var container = createFeedContainer(feedID, parentIndex, instantSearchInstance);
+                feedContainersRef.current.set(feedID, container);
+                toAdd.push(container);
+            }
         });
-        return /*#__PURE__*/ React.createElement(React.Fragment, null, attributesToRender.map(function(attribute) {
-            return /*#__PURE__*/ React.createElement(React.Fragment, {
-                key: attribute
-            }, widgets.get(attribute) || /*#__PURE__*/ React.createElement(FallbackComponent.current, {
-                attribute: attribute
-            }));
-        }));
-    }
-    function isReactElement(element) {
-        return (typeof element === "undefined" ? "undefined" : _type_of(element)) === 'object' && element.props;
-    }
-    function getWidgetAttribute(element) {
-        if (!isReactElement(element)) {
-            return undefined;
-        }
-        if (element.props.attribute) {
-            return element.props.attribute;
-        }
-        if (Array.isArray(element.props.attributes)) {
-            return element.props.attributes[0];
-        }
-        if (element.props.children) {
-            invariant(React.Children.count(element.props.children) === 1);
-            return getWidgetAttribute(React.Children.only(element.props.children));
-        }
-        return undefined;
-    }
-
-    function _array_without_holes(arr) {
-        if (Array.isArray(arr)) return _array_like_to_array(arr);
-    }
-
-    function _non_iterable_spread() {
-        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-
-    function _to_consumable_array(arr) {
-        return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-    }
-
-    var id$1 = 0;
-    function addWidgetId(widget) {
-        if (widget.dependsOn !== 'recommend') {
-            return;
+        if (toAdd.length > 0) {
+            parentIndex.addWidgets(toAdd);
         }
-        widget.$$id = id$1++;
-    }
-    function resetWidgetId() {
-        id$1 = 0;
-    }
-
-    function isIndexWidget(widget) {
-        return widget.$$type === 'ais.index';
-    }
-
-    var nextMicroTask = Promise.resolve();
-    function defer(callback) {
-        var progress = null;
-        var cancelled = false;
-        var fn = function fn() {
-            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                args[_key] = arguments[_key];
-            }
-            if (progress !== null) {
-                return;
-            }
-            progress = nextMicroTask.then(function() {
-                progress = null;
-                if (cancelled) {
-                    cancelled = false;
-                    return;
+        // Remove containers that are no longer in feedIDs (deferred to match useWidget pattern).
+        React.useEffect(function() {
+            var containers = feedContainersRef.current;
+            var activeSet = new Set(feedIDs);
+            var toRemove = [];
+            containers.forEach(function(container, id) {
+                if (!activeSet.has(id)) {
+                    toRemove.push([
+                        id,
+                        container
+                    ]);
+                    containers.delete(id);
                 }
-                callback.apply(void 0, _to_consumable_array(args));
             });
-        };
-        fn.wait = function() {
-            if (progress === null) {
-                throw new Error('The deferred function should be called before calling `wait()`');
+            if (toRemove.length > 0) {
+                toRemove.forEach(function(param) {
+                    var _param = _sliced_to_array(param, 2), id = _param[0], container = _param[1];
+                    pendingRemovalsRef.current.set(id, container);
+                });
+                if (removalTimerRef.current !== null) {
+                    clearTimeout(removalTimerRef.current);
+                }
+                removalTimerRef.current = setTimeout(function() {
+                    var widgetsToRemove = Array.from(pendingRemovalsRef.current.values());
+                    pendingRemovalsRef.current.clear();
+                    removalTimerRef.current = null;
+                    if (widgetsToRemove.length > 0) {
+                        parentIndex.removeWidgets(widgetsToRemove);
+                    }
+                }, 0);
             }
-            return progress;
-        };
-        fn.cancel = function() {
-            if (progress === null) {
-                return;
+        }, [
+            feedIDs,
+            parentIndex
+        ]);
+        React.useEffect(function() {
+            return function() {
+                if (removalTimerRef.current !== null) {
+                    clearTimeout(removalTimerRef.current);
+                    removalTimerRef.current = null;
+                }
+                var containers = feedContainersRef.current;
+                var toRemove = Array.from(new Set(_to_consumable_array(containers.values()).concat(_to_consumable_array(pendingRemovalsRef.current.values()))));
+                pendingRemovalsRef.current.clear();
+                containers.clear();
+                if (toRemove.length > 0) {
+                    parentIndex.removeWidgets(toRemove);
+                }
+            };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, []);
+        return /*#__PURE__*/ React.createElement(React.Fragment, null, feedIDs.map(function(feedID) {
+            var container = feedContainersRef.current.get(feedID);
+            if (!container) {
+                return null;
             }
-            cancelled = true;
-        };
-        return fn;
-    }
-
-    function resolveSearchParameters(current) {
-        var parent = current.getParent();
-        var states = [
-            current.getHelper().state
-        ];
-        while(parent !== null){
-            states = [
-                parent.getHelper().state
-            ].concat(states);
-            parent = parent.getParent();
-        }
-        return states;
-    }
-
-    function createInitArgs(instantSearchInstance, parent, uiState) {
-        var helper = parent.getHelper();
-        return {
-            uiState: uiState,
-            helper: helper,
-            parent: parent,
-            instantSearchInstance: instantSearchInstance,
-            state: helper.state,
-            renderState: instantSearchInstance.renderState,
-            templatesConfig: instantSearchInstance.templatesConfig,
-            createURL: parent.createURL,
-            scopedResults: [],
-            searchMetadata: {
-                isSearchStalled: instantSearchInstance.status === 'stalled'
-            },
-            status: instantSearchInstance.status,
-            error: instantSearchInstance.error
-        };
-    }
-    function createRenderArgs(instantSearchInstance, parent, widget) {
-        var results = parent.getResultsForWidget(widget);
-        var helper = parent.getHelper();
-        return {
-            helper: helper,
-            parent: parent,
-            instantSearchInstance: instantSearchInstance,
-            results: results,
-            scopedResults: parent.getScopedResults(),
-            state: results && '_state' in results ? results._state : helper.state,
-            renderState: instantSearchInstance.renderState,
-            templatesConfig: instantSearchInstance.templatesConfig,
-            createURL: parent.createURL,
-            searchMetadata: {
-                isSearchStalled: instantSearchInstance.status === 'stalled'
-            },
-            status: instantSearchInstance.status,
-            error: instantSearchInstance.error
-        };
+            return /*#__PURE__*/ React.createElement(IndexContext.Provider, {
+                key: feedID,
+                value: container
+            }, renderFeed({
+                feedID: feedID
+            }));
+        }));
     }
 
     var withUsage$r = createDocumentationMessageGenerator({
@@ -7445,11 +8861,6 @@
             }
         };
     };
-    function storeRenderState(param) {
-        var renderState = param.renderState, instantSearchInstance = param.instantSearchInstance, parent = param.parent;
-        var parentIndexName = parent ? parent.getIndexId() : instantSearchInstance.mainIndex.getIndexId();
-        instantSearchInstance.renderState = _object_spread_props(_object_spread({}, instantSearchInstance.renderState), _define_property({}, parentIndexName, _object_spread({}, instantSearchInstance.renderState[parentIndexName], renderState)));
-    }
     /**
      * Walk up the parent chain to find the closest isolated index, or fall back to mainHelper
      */ function nearestIsolatedHelper(current, mainHelper) {
@@ -7613,99 +9024,32 @@
      */ function createUUID() {
         return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
             /* eslint-disable no-bitwise */ var r = Math.random() * 16 | 0;
-            var v = c === 'x' ? r : r & 0x3 | 0x8;
-            /* eslint-enable */ return v.toString(16);
-        });
-    }
-
-    var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
-    function getCookie(name) {
-        if ((typeof document === "undefined" ? "undefined" : _type_of(document)) !== 'object' || typeof document.cookie !== 'string') {
-            return undefined;
-        }
-        var prefix = "".concat(name, "=");
-        var cookies = document.cookie.split(';');
-        for(var i = 0; i < cookies.length; i++){
-            var cookie = cookies[i];
-            while(cookie.charAt(0) === ' '){
-                cookie = cookie.substring(1);
-            }
-            if (cookie.indexOf(prefix) === 0) {
-                return cookie.substring(prefix.length, cookie.length);
-            }
-        }
-        return undefined;
-    }
-    function getInsightsAnonymousUserTokenInternal() {
-        return getCookie(ANONYMOUS_TOKEN_COOKIE_KEY);
-    }
-
-    // eslint-disable-next-line no-restricted-globals
-    /**
-     * Runs code on browser environments safely.
-     */ function safelyRunOnBrowser(callback) {
-        var fallback = (arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
-            fallback: function fallback() {
-                return undefined;
-            }
-        }).fallback;
-        // eslint-disable-next-line no-restricted-globals
-        if (typeof window === 'undefined') {
-            return fallback();
-        }
-        // eslint-disable-next-line no-restricted-globals
-        return callback({
-            window: window
+            var v = c === 'x' ? r : r & 0x3 | 0x8;
+            /* eslint-enable */ return v.toString(16);
         });
     }
 
-    // typed as any, since it accepts the _real_ js clients, not the interface we otherwise expect
-    function getAppIdAndApiKey(searchClient) {
-        if (searchClient.appId && searchClient.apiKey) {
-            // searchClient v5
-            return [
-                searchClient.appId,
-                searchClient.apiKey
-            ];
-        } else if (searchClient.transporter) {
-            // searchClient v4 or v5
-            var transporter = searchClient.transporter;
-            var headers = transporter.headers || transporter.baseHeaders;
-            var queryParameters = transporter.queryParameters || transporter.baseQueryParameters;
-            var APP_ID = 'x-algolia-application-id';
-            var API_KEY = 'x-algolia-api-key';
-            var appId = headers[APP_ID] || queryParameters[APP_ID];
-            var apiKey = headers[API_KEY] || queryParameters[API_KEY];
-            return [
-                appId,
-                apiKey
-            ];
-        } else {
-            // searchClient v3
-            return [
-                searchClient.applicationID,
-                searchClient.apiKey
-            ];
+    var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
+    function getCookie(name) {
+        if ((typeof document === "undefined" ? "undefined" : _type_of(document)) !== 'object' || typeof document.cookie !== 'string') {
+            return undefined;
         }
-    }
-
-    // We aren't using the native `Array.prototype.find` because the refactor away from Lodash is not
-    // published as a major version.
-    // Relying on the `find` polyfill on user-land, which before was only required for niche use-cases,
-    // was decided as too risky.
-    // @MAJOR Replace with the native `Array.prototype.find` method
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
-    function find$1(items, predicate) {
-        var value;
-        for(var i = 0; i < items.length; i++){
-            value = items[i];
-            // inlined for performance: if (Call(predicate, thisArg, [value, i, list])) {
-            if (predicate(value, i, items)) {
-                return value;
+        var prefix = "".concat(name, "=");
+        var cookies = document.cookie.split(';');
+        for(var i = 0; i < cookies.length; i++){
+            var cookie = cookies[i];
+            while(cookie.charAt(0) === ' '){
+                cookie = cookie.substring(1);
+            }
+            if (cookie.indexOf(prefix) === 0) {
+                return cookie.substring(prefix.length, cookie.length);
             }
         }
         return undefined;
     }
+    function getInsightsAnonymousUserTokenInternal() {
+        return getCookie(ANONYMOUS_TOKEN_COOKIE_KEY);
+    }
 
     var ALGOLIA_INSIGHTS_VERSION = '2.17.2';
     var ALGOLIA_INSIGHTS_SRC = "https://cdn.jsdelivr.net/npm/search-insights@".concat(ALGOLIA_INSIGHTS_VERSION, "/dist/search-insights.min.js");
@@ -8021,11 +9365,6 @@
         return typeof userToken === 'number' ? userToken.toString() : userToken;
     }
 
-    function getAlgoliaAgent(client) {
-        var clientTyped = client;
-        return clientTyped.transporter && clientTyped.transporter.userAgent ? clientTyped.transporter.userAgent.value : clientTyped._ua;
-    }
-
     function extractWidgetPayload(widgets, instantSearchInstance, payload) {
         var initOptions = createInitArgs(instantSearchInstance, instantSearchInstance.mainIndex, instantSearchInstance._initialUiState);
         widgets.forEach(function(widget) {
@@ -8046,7 +9385,7 @@
                 widgetType: widget.$$widgetType,
                 params: params
             });
-            if (widget.$$type === 'ais.index') {
+            if (isIndexWidget(widget)) {
                 extractWidgetPayload(widget.getWidgets(), instantSearchInstance, payload);
             }
         });
@@ -9261,55 +10600,16 @@
             routeToState: function routeToState() {
                 var routeState = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
                 return Object.keys(routeState).reduce(function(state, indexId) {
-                    return _object_spread_props(_object_spread({}, state), _define_property({}, indexId, getIndexStateWithoutConfigure(routeState[indexId])));
+                    var indexState = routeState[indexId];
+                    if ((typeof indexState === "undefined" ? "undefined" : _type_of(indexState)) !== 'object' || indexState === null) {
+                        return state;
+                    }
+                    return _object_spread_props(_object_spread({}, state), _define_property({}, indexId, getIndexStateWithoutConfigure(indexState)));
                 }, {});
             }
         };
     }
 
-    function isPrimitive(obj) {
-        return obj !== Object(obj);
-    }
-    function isEqual(first, second) {
-        if (first === second) {
-            return true;
-        }
-        if (isPrimitive(first) || isPrimitive(second) || typeof first === 'function' || typeof second === 'function') {
-            return first === second;
-        }
-        if (Object.keys(first).length !== Object.keys(second).length) {
-            return false;
-        }
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            // @TODO avoid for..of because of the large polyfill
-            // eslint-disable-next-line instantsearch/no-for-of
-            for(var _iterator = Object.keys(first)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var key = _step.value;
-                if (!(key in second)) {
-                    return false;
-                }
-                if (!isEqual(first[key], second[key])) {
-                    return false;
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-        return true;
-    }
-
     var createRouterMiddleware = function createRouterMiddleware() {
         var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
         var _props_router = props.router, router = _props_router === void 0 ? historyRouter() : _props_router, _props_stateMapping = props.// this is needed because simpleStateMapping is StateMapping<TUiState, TUiState>.
@@ -9343,166 +10643,43 @@
                     var uiState = param.uiState;
                     var routeState = stateMapping.stateToRoute(uiState);
                     if (lastRouteState === undefined || !isEqual(lastRouteState, routeState)) {
-                        router.write(routeState);
-                        lastRouteState = routeState;
-                    }
-                },
-                subscribe: function subscribe() {
-                    instantSearchInstance._initialUiState = _object_spread({}, initialUiState, stateMapping.routeToState(router.read()));
-                    router.onUpdate(function(route) {
-                        if (instantSearchInstance.mainIndex.getWidgets().length > 0) {
-                            instantSearchInstance.setUiState(stateMapping.routeToState(route));
-                        }
-                    });
-                },
-                started: function started() {
-                    var _router_start;
-                    (_router_start = router.start) === null || _router_start === void 0 ? void 0 : _router_start.call(router);
-                },
-                unsubscribe: function unsubscribe() {
-                    router.dispose();
-                }
-            };
-        };
-    };
-
-    function formatNumber(value, numberLocale) {
-        return value.toLocaleString(numberLocale);
-    }
-
-    var NAMESPACE = 'ais';
-    var component = function component(componentName) {
-        return function() {
-            var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, descendantName = _ref.descendantName, modifierName = _ref.modifierName;
-            var descendent = descendantName ? "-".concat(descendantName) : '';
-            var modifier = modifierName ? "--".concat(modifierName) : '';
-            return "".concat(NAMESPACE, "-").concat(componentName).concat(descendent).concat(modifier);
-        };
-    };
-
-    function getPropertyByPath(object, path) {
-        var parts = Array.isArray(path) ? path : path.split('.');
-        return parts.reduce(function(current, key) {
-            return current && current[key];
-        }, object);
-    }
-
-    function _extends() {
-        _extends = Object.assign || function assign(target) {
-            for (var i = 1; i < arguments.length; i++) {
-                var source = arguments[i];
-                for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
-            }
-
-            return target;
-        };
-
-        return _extends.apply(this, arguments);
-    }
-
-    function _object_destructuring_empty(o) {
-        if (o === null || o === void 0) throw new TypeError("Cannot destructure " + o);
-
-        return o;
-    }
-
-    /**
-     * This implementation is taken from Lodash implementation.
-     * See: https://github.com/lodash/lodash/blob/4.17.11-npm/escape.js
-     */ // Used to map characters to HTML entities.
-    var htmlEntities = {
-        '&': '&amp;',
-        '<': '&lt;',
-        '>': '&gt;',
-        '"': '&quot;',
-        "'": '&#39;'
-    };
-    // Used to match HTML entities and HTML characters.
-    var regexUnescapedHtml = /[&<>"']/g;
-    var regexHasUnescapedHtml = RegExp(regexUnescapedHtml.source);
-    /**
-     * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
-     * corresponding HTML entities.
-     */ function escape$1(value) {
-        return value && regexHasUnescapedHtml.test(value) ? value.replace(regexUnescapedHtml, function(character) {
-            return htmlEntities[character];
-        }) : value;
-    }
-    /**
-     * This implementation is taken from Lodash implementation.
-     * See: https://github.com/lodash/lodash/blob/4.17.11-npm/unescape.js
-     */ // Used to map HTML entities to characters.
-    var htmlCharacters = {
-        '&amp;': '&',
-        '&lt;': '<',
-        '&gt;': '>',
-        '&quot;': '"',
-        '&#39;': "'"
-    };
-    // Used to match HTML entities and HTML characters.
-    var regexEscapedHtml = /&(amp|quot|lt|gt|#39);/g;
-    var regexHasEscapedHtml = RegExp(regexEscapedHtml.source);
-    /**
-     * Converts the HTML entities "&", "<", ">", '"', and "'" in `string` to their
-     * characters.
-     */ function unescape$1(value) {
-        return value && regexHasEscapedHtml.test(value) ? value.replace(regexEscapedHtml, function(character) {
-            return htmlCharacters[character];
-        }) : value;
-    }
-
-    var TAG_PLACEHOLDER = {
-        highlightPreTag: '__ais-highlight__',
-        highlightPostTag: '__/ais-highlight__'
-    };
-    var TAG_REPLACEMENT = {
-        highlightPreTag: '<mark>',
-        highlightPostTag: '</mark>'
-    };
-    // @MAJOR: in the future, this should only escape, not replace
-    function replaceTagsAndEscape(value) {
-        return escape$1(value).replace(new RegExp(TAG_PLACEHOLDER.highlightPreTag, 'g'), TAG_REPLACEMENT.highlightPreTag).replace(new RegExp(TAG_PLACEHOLDER.highlightPostTag, 'g'), TAG_REPLACEMENT.highlightPostTag);
-    }
-    function recursiveEscape(input) {
-        if (isPlainObject(input) && typeof input.value !== 'string') {
-            return Object.keys(input).reduce(function(acc, key) {
-                return _object_spread_props(_object_spread({}, acc), _define_property({}, key, recursiveEscape(input[key])));
-            }, {});
-        }
-        if (Array.isArray(input)) {
-            return input.map(recursiveEscape);
-        }
-        return _object_spread_props(_object_spread({}, input), {
-            value: replaceTagsAndEscape(input.value)
-        });
-    }
-    function escapeHits(hits) {
-        if (hits.__escaped === undefined) {
-            // We don't override the value on hit because it will mutate the raw results
-            // instead we make a shallow copy and we assign the escaped values on it.
-            hits = hits.map(function(_0) {
-                _object_destructuring_empty(_0);
-                var hit = _extends({}, _0);
-                if (hit._highlightResult) {
-                    hit._highlightResult = recursiveEscape(hit._highlightResult);
-                }
-                if (hit._snippetResult) {
-                    hit._snippetResult = recursiveEscape(hit._snippetResult);
+                        router.write(routeState);
+                        lastRouteState = routeState;
+                    }
+                },
+                subscribe: function subscribe() {
+                    instantSearchInstance._initialUiState = _object_spread({}, initialUiState, stateMapping.routeToState(router.read()));
+                    router.onUpdate(function(route) {
+                        if (instantSearchInstance.mainIndex.getWidgets().length > 0) {
+                            instantSearchInstance.setUiState(stateMapping.routeToState(route));
+                        }
+                    });
+                },
+                started: function started() {
+                    var _router_start;
+                    (_router_start = router.start) === null || _router_start === void 0 ? void 0 : _router_start.call(router);
+                },
+                unsubscribe: function unsubscribe() {
+                    router.dispose();
                 }
-                return hit;
-            });
-            hits.__escaped = true;
-        }
-        return hits;
-    }
-    function escapeFacets(facetHits) {
-        return facetHits.map(function(h) {
-            return _object_spread_props(_object_spread({}, h), {
-                highlighted: replaceTagsAndEscape(h.highlighted)
-            });
-        });
+            };
+        };
+    };
+
+    function formatNumber(value, numberLocale) {
+        return value.toLocaleString(numberLocale);
     }
 
+    var NAMESPACE = 'ais';
+    var component = function component(componentName) {
+        return function() {
+            var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, descendantName = _ref.descendantName, modifierName = _ref.modifierName;
+            var descendent = descendantName ? "-".concat(descendantName) : '';
+            var modifier = modifierName ? "--".concat(modifierName) : '';
+            return "".concat(NAMESPACE, "-").concat(componentName).concat(descendent).concat(modifier);
+        };
+    };
+
     var suit$3 = component('Highlight');
     /**
      * @deprecated use html tagged templates and the Highlight component instead
@@ -9517,69 +10694,6 @@
         return attributeValue.replace(new RegExp(TAG_REPLACEMENT.highlightPreTag, 'g'), "<".concat(highlightedTagName, ' class="').concat(className, '">')).replace(new RegExp(TAG_REPLACEMENT.highlightPostTag, 'g'), "</".concat(highlightedTagName, ">"));
     }
 
-    function concatHighlightedParts(parts) {
-        var highlightPreTag = TAG_REPLACEMENT.highlightPreTag, highlightPostTag = TAG_REPLACEMENT.highlightPostTag;
-        return parts.map(function(part) {
-            return part.isHighlighted ? highlightPreTag + part.value + highlightPostTag : part.value;
-        }).join('');
-    }
-
-    var hasAlphanumeric = new RegExp(/\w/i);
-    function getHighlightFromSiblings(parts, i) {
-        var _parts_, _parts_1;
-        var current = parts[i];
-        var isNextHighlighted = ((_parts_ = parts[i + 1]) === null || _parts_ === void 0 ? void 0 : _parts_.isHighlighted) || true;
-        var isPreviousHighlighted = ((_parts_1 = parts[i - 1]) === null || _parts_1 === void 0 ? void 0 : _parts_1.isHighlighted) || true;
-        if (!hasAlphanumeric.test(unescape$1(current.value)) && isPreviousHighlighted === isNextHighlighted) {
-            return isPreviousHighlighted;
-        }
-        return current.isHighlighted;
-    }
-
-    function reverseHighlightedParts(parts) {
-        if (!parts.some(function(part) {
-            return part.isHighlighted;
-        })) {
-            return parts.map(function(part) {
-                return _object_spread_props(_object_spread({}, part), {
-                    isHighlighted: false
-                });
-            });
-        }
-        return parts.map(function(part, i) {
-            return _object_spread_props(_object_spread({}, part), {
-                isHighlighted: !getHighlightFromSiblings(parts, i)
-            });
-        });
-    }
-
-    function getHighlightedParts(highlightedValue) {
-        // @MAJOR: this should use TAG_PLACEHOLDER
-        var highlightPostTag = TAG_REPLACEMENT.highlightPostTag, highlightPreTag = TAG_REPLACEMENT.highlightPreTag;
-        var splitByPreTag = highlightedValue.split(highlightPreTag);
-        var firstValue = splitByPreTag.shift();
-        var elements = !firstValue ? [] : [
-            {
-                value: firstValue,
-                isHighlighted: false
-            }
-        ];
-        splitByPreTag.forEach(function(split) {
-            var splitByPostTag = split.split(highlightPostTag);
-            elements.push({
-                value: splitByPostTag[0],
-                isHighlighted: true
-            });
-            if (splitByPostTag[1] !== '') {
-                elements.push({
-                    value: splitByPostTag[1],
-                    isHighlighted: false
-                });
-            }
-        });
-        return elements;
-    }
-
     var suit$2 = component('ReverseHighlight');
     /**
      * @deprecated use html tagged templates and the ReverseHighlight component instead
@@ -9624,10 +10738,6 @@
         return reverseHighlightedValue.replace(new RegExp(TAG_REPLACEMENT.highlightPreTag, 'g'), "<".concat(highlightedTagName, ' class="').concat(className, '">')).replace(new RegExp(TAG_REPLACEMENT.highlightPostTag, 'g'), "</".concat(highlightedTagName, ">"));
     }
 
-    function serializePayload(payload) {
-        return btoa(encodeURIComponent(JSON.stringify(payload)));
-    }
-
     /** @deprecated use bindEvent instead */ function writeDataAttributes(param) {
         var method = param.method, payload = param.payload;
         if ((typeof payload === "undefined" ? "undefined" : _type_of(payload)) !== 'object') {
@@ -9666,185 +10776,52 @@
                     throw new Error('\nThe highlight helper expects a JSON object of the format:\n{ "attribute": "name", "highlightedTagName": "mark" }');
                 }
             },
-            reverseHighlight: function reverseHighlight1(options, render) {
-                try {
-                    var reverseHighlightOptions = JSON.parse(options);
-                    return render(reverseHighlight(_object_spread_props(_object_spread({}, reverseHighlightOptions), {
-                        hit: this
-                    })));
-                } catch (error) {
-                    throw new Error('\n  The reverseHighlight helper expects a JSON object of the format:\n  { "attribute": "name", "highlightedTagName": "mark" }');
-                }
-            },
-            snippet: function snippet1(options, render) {
-                try {
-                    var snippetOptions = JSON.parse(options);
-                    return render(snippet(_object_spread_props(_object_spread({}, snippetOptions), {
-                        hit: this
-                    })));
-                } catch (error) {
-                    throw new Error('\nThe snippet helper expects a JSON object of the format:\n{ "attribute": "name", "highlightedTagName": "mark" }');
-                }
-            },
-            reverseSnippet: function reverseSnippet1(options, render) {
-                try {
-                    var reverseSnippetOptions = JSON.parse(options);
-                    return render(reverseSnippet(_object_spread_props(_object_spread({}, reverseSnippetOptions), {
-                        hit: this
-                    })));
-                } catch (error) {
-                    throw new Error('\n  The reverseSnippet helper expects a JSON object of the format:\n  { "attribute": "name", "highlightedTagName": "mark" }');
-                }
-            },
-            insights: function insights1(options, render) {
-                try {
-                    var _JSON_parse = JSON.parse(options), method = _JSON_parse.method, payload = _JSON_parse.payload;
-                    return render(insights(method, _object_spread({
-                        objectIDs: [
-                            this.objectID
-                        ]
-                    }, payload)));
-                } catch (error) {
-                    throw new Error('\nThe insights helper expects a JSON object of the format:\n{ "method": "method-name", "payload": { "eventName": "name of the event" } }');
-                }
-            }
-        };
-    }
-
-    var version = '4.95.0';
-
-    function hydrateSearchClient(client, results) {
-        if (!results) {
-            return;
-        }
-        // Disable cache hydration on:
-        // - Algoliasearch API Client < v4 with cache disabled
-        // - Third party clients (detected by the `addAlgoliaAgent` function missing)
-        if ((!('transporter' in client) || client._cacheHydrated) && (!client._useCache || typeof client.addAlgoliaAgent !== 'function')) {
-            return;
-        }
-        var cachedRequest = [
-            Object.keys(results).reduce(function(acc, key) {
-                var _results_key = results[key], state = _results_key.state, requestParams = _results_key.requestParams, serverResults = _results_key.results;
-                var mappedResults = serverResults && state ? serverResults.map(function(result, idx) {
-                    return _object_spread({
-                        indexName: state.index || result.index
-                    }, (requestParams === null || requestParams === void 0 ? void 0 : requestParams[idx]) || result.params ? {
-                        params: serializeQueryParameters((requestParams === null || requestParams === void 0 ? void 0 : requestParams[idx]) || deserializeQueryParameters(result.params))
-                    } : {});
-                }) : [];
-                return acc.concat(mappedResults);
-            }, [])
-        ];
-        var cachedResults = Object.keys(results).reduce(function(acc, key) {
-            var res = results[key].results;
-            if (!res) {
-                return acc;
-            }
-            return acc.concat(res);
-        }, []);
-        // Algoliasearch API Client >= v4
-        // To hydrate the client we need to populate the cache with the data from
-        // the server (done in `hydrateSearchClientWithMultiIndexRequest` or
-        // `hydrateSearchClientWithSingleIndexRequest`). But since there is no way
-        // for us to compute the key the same way as `algoliasearch-client` we need
-        // to populate it on a custom key and override the `search` method to
-        // search on it first.
-        if ('transporter' in client && !client._cacheHydrated) {
-            client._cacheHydrated = true;
-            var baseMethod = client.search.bind(client);
-            client.search = function(requests) {
-                for(var _len = arguments.length, methodArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
-                    methodArgs[_key - 1] = arguments[_key];
-                }
-                var requestsWithSerializedParams = Array.isArray(requests) ? requests.map(function(request) {
-                    return _object_spread_props(_object_spread({}, request), {
-                        params: serializeQueryParameters(request.params)
-                    });
-                }) : serializeQueryParameters(requests.requestBody.params);
-                return client.transporter.responsesCache.get({
-                    method: 'search',
-                    args: [
-                        requestsWithSerializedParams
-                    ].concat(_to_consumable_array(methodArgs))
-                }, function() {
-                    return baseMethod.apply(void 0, [
-                        requests
-                    ].concat(_to_consumable_array(methodArgs)));
-                });
-            };
-            client.transporter.responsesCache.set({
-                method: 'search',
-                args: cachedRequest
-            }, {
-                results: cachedResults
-            });
-        }
-        // Algoliasearch API Client < v4
-        // Prior to client v4 we didn't have a proper API to hydrate the client
-        // cache from the outside. The following code populates the cache with
-        // a single-index result. You can find more information about the
-        // computation of the key inside the client (see link below).
-        // https://github.com/algolia/algoliasearch-client-javascript/blob/c27e89ff92b2a854ae6f40dc524bffe0f0cbc169/src/AlgoliaSearchCore.js#L232-L240
-        if (!('transporter' in client)) {
-            var cacheKey = "/1/indexes/*/queries_body_".concat(JSON.stringify({
-                requests: cachedRequest
-            }));
-            client.cache = _object_spread_props(_object_spread({}, client.cache), _define_property({}, cacheKey, JSON.stringify({
-                results: Object.keys(results).map(function(key) {
-                    return results[key].results;
-                })
-            })));
-        }
-    }
-    function deserializeQueryParameters(parameters) {
-        return parameters.split('&').reduce(function(acc, parameter) {
-            var _parameter_split = _sliced_to_array(parameter.split('='), 2), key = _parameter_split[0], value = _parameter_split[1];
-            acc[key] = value ? decodeURIComponent(value) : '';
-            return acc;
-        }, {});
-    }
-    // This function is copied from the algoliasearch v4 API Client. If modified,
-    // consider updating it also in `serializeQueryParameters` from `@algolia/transporter`.
-    function serializeQueryParameters(parameters) {
-        var isObjectOrArray = function isObjectOrArray(value) {
-            return Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === '[object Array]';
-        };
-        var encode = function encode(format) {
-            for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
-                args[_key - 1] = arguments[_key];
+            reverseHighlight: function reverseHighlight1(options, render) {
+                try {
+                    var reverseHighlightOptions = JSON.parse(options);
+                    return render(reverseHighlight(_object_spread_props(_object_spread({}, reverseHighlightOptions), {
+                        hit: this
+                    })));
+                } catch (error) {
+                    throw new Error('\n  The reverseHighlight helper expects a JSON object of the format:\n  { "attribute": "name", "highlightedTagName": "mark" }');
+                }
+            },
+            snippet: function snippet1(options, render) {
+                try {
+                    var snippetOptions = JSON.parse(options);
+                    return render(snippet(_object_spread_props(_object_spread({}, snippetOptions), {
+                        hit: this
+                    })));
+                } catch (error) {
+                    throw new Error('\nThe snippet helper expects a JSON object of the format:\n{ "attribute": "name", "highlightedTagName": "mark" }');
+                }
+            },
+            reverseSnippet: function reverseSnippet1(options, render) {
+                try {
+                    var reverseSnippetOptions = JSON.parse(options);
+                    return render(reverseSnippet(_object_spread_props(_object_spread({}, reverseSnippetOptions), {
+                        hit: this
+                    })));
+                } catch (error) {
+                    throw new Error('\n  The reverseSnippet helper expects a JSON object of the format:\n  { "attribute": "name", "highlightedTagName": "mark" }');
+                }
+            },
+            insights: function insights1(options, render) {
+                try {
+                    var _JSON_parse = JSON.parse(options), method = _JSON_parse.method, payload = _JSON_parse.payload;
+                    return render(insights(method, _object_spread({
+                        objectIDs: [
+                            this.objectID
+                        ]
+                    }, payload)));
+                } catch (error) {
+                    throw new Error('\nThe insights helper expects a JSON object of the format:\n{ "method": "method-name", "payload": { "eventName": "name of the event" } }');
+                }
             }
-            var i = 0;
-            return format.replace(/%s/g, function() {
-                return encodeURIComponent(args[i++]);
-            });
         };
-        return Object.keys(parameters).map(function(key) {
-            return encode('%s=%s', key, isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key]);
-        }).join('&');
     }
 
-    function hydrateRecommendCache(helper, initialResults) {
-        var recommendCache = Object.keys(initialResults).reduce(function(acc, indexName) {
-            var initialResult = initialResults[indexName];
-            if (initialResult.recommendResults) {
-                // @MAJOR: Use `Object.assign` instead of spread operator
-                return _object_spread({}, acc, initialResult.recommendResults.results);
-            }
-            return acc;
-        }, {});
-        helper._recommendCache = recommendCache;
-    }
-
-    function setIndexHelperState(finalUiState, indexWidget) {
-        var nextIndexUiState = finalUiState[indexWidget.getIndexId()] || {};
-        indexWidget.getHelper().setState(indexWidget.getWidgetSearchParameters(indexWidget.getHelper().state, {
-            uiState: nextIndexUiState
-        }));
-        indexWidget.getWidgets().filter(isIndexWidget).forEach(function(widget) {
-            return setIndexHelperState(finalUiState, widget);
-        });
-    }
+    var version = '4.96.0';
 
     var withUsage$q = createDocumentationMessageGenerator({
         name: 'instantsearch'
@@ -10847,193 +11824,19 @@
         var ssrSearchRef = React.useRef(null);
         // This is used to re-map the result index to the requesting widget
         var recommendIdx = React.useRef(0);
-        // When <DynamicWidgets> is mounted, a second provider is used above the user-land
-        // <InstantSearchSSRProvider> in `getServerState()`.
-        // To avoid the user's provider overriding the context value with an empty object,
-        // we skip this provider.
-        if (Object.keys(props).length === 0) {
-            return /*#__PURE__*/ React.createElement(React.Fragment, null, children);
-        }
-        return /*#__PURE__*/ React.createElement(InstantSearchSSRContext.Provider, {
-            value: _object_spread_props(_object_spread({}, props), {
-                ssrSearchRef: ssrSearchRef,
-                recommendIdx: recommendIdx
-            })
-        }, children);
-    }
-
-    function chunk(arr) {
-        var chunkSize = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 20;
-        var chunks = [];
-        for(var i = 0; i < Math.ceil(arr.length / chunkSize); i++){
-            chunks.push(arr.slice(i * chunkSize, (i + 1) * chunkSize));
-        }
-        return chunks;
-    }
-    function _buildEventPayloadsForHits(param) {
-        var helper = param.helper, widgetType = param.widgetType;
-        param.methodName;
-        var args = param.args, instantSearchInstance = param.instantSearchInstance;
-        // when there's only one argument, that means it's custom
-        if (args.length === 1 && _type_of(args[0]) === 'object') {
-            return [
-                args[0]
-            ];
-        }
-        var _args__split = _sliced_to_array(args[0].split(':'), 2), eventType = _args__split[0], eventModifier = _args__split[1];
-        var hits = args[1];
-        var eventName = args[2];
-        var additionalData = args[3] || {};
-        if (!hits) {
-            {
-                return [];
-            }
-        }
-        if ((eventType === 'click' || eventType === 'conversion') && !eventName) {
-            {
-                return [];
-            }
-        }
-        var hitsArray = Array.isArray(hits) ? hits : [
-            hits
-        ];
-        if (hitsArray.length === 0) {
-            return [];
-        }
-        var queryID = hitsArray[0].__queryID;
-        var hitsChunks = chunk(hitsArray);
-        var objectIDsByChunk = hitsChunks.map(function(batch) {
-            return batch.map(function(hit) {
-                return hit.objectID;
-            });
-        });
-        var positionsByChunk = hitsChunks.map(function(batch) {
-            return batch.map(function(hit) {
-                return hit.__position;
-            });
-        });
-        if (eventType === 'view') {
-            if (instantSearchInstance.status !== 'idle') {
-                return [];
-            }
-            return hitsChunks.map(function(batch, i) {
-                var _helper_lastResults;
-                return {
-                    insightsMethod: 'viewedObjectIDs',
-                    widgetType: widgetType,
-                    eventType: eventType,
-                    payload: _object_spread({
-                        eventName: eventName || 'Hits Viewed',
-                        index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
-                        objectIDs: objectIDsByChunk[i]
-                    }, additionalData),
-                    hits: batch,
-                    eventModifier: eventModifier
-                };
-            });
-        } else if (eventType === 'click') {
-            return hitsChunks.map(function(batch, i) {
-                var _helper_lastResults;
-                return {
-                    insightsMethod: 'clickedObjectIDsAfterSearch',
-                    widgetType: widgetType,
-                    eventType: eventType,
-                    payload: _object_spread({
-                        eventName: eventName || 'Hit Clicked',
-                        index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
-                        queryID: queryID,
-                        objectIDs: objectIDsByChunk[i],
-                        positions: positionsByChunk[i]
-                    }, additionalData),
-                    hits: batch,
-                    eventModifier: eventModifier
-                };
-            });
-        } else if (eventType === 'conversion') {
-            return hitsChunks.map(function(batch, i) {
-                var _helper_lastResults;
-                return {
-                    insightsMethod: 'convertedObjectIDsAfterSearch',
-                    widgetType: widgetType,
-                    eventType: eventType,
-                    payload: _object_spread({
-                        eventName: eventName || 'Hit Converted',
-                        index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
-                        queryID: queryID,
-                        objectIDs: objectIDsByChunk[i]
-                    }, additionalData),
-                    hits: batch,
-                    eventModifier: eventModifier
-                };
-            });
-        } else {
-            return [];
-        }
-    }
-    function createSendEventForHits(param) {
-        var instantSearchInstance = param.instantSearchInstance, helper = param.helper, widgetType = param.widgetType;
-        var sentEvents = {};
-        var timer = undefined;
-        var sendEventForHits = function sendEventForHits() {
-            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                args[_key] = arguments[_key];
-            }
-            var payloads = _buildEventPayloadsForHits({
-                widgetType: widgetType,
-                helper: helper,
-                methodName: 'sendEvent',
-                args: args,
-                instantSearchInstance: instantSearchInstance
-            });
-            payloads.forEach(function(payload) {
-                if (payload.eventType === 'click' && payload.eventModifier === 'internal' && sentEvents[payload.eventType]) {
-                    return;
-                }
-                sentEvents[payload.eventType] = true;
-                instantSearchInstance.sendEventToInsights(payload);
-            });
-            clearTimeout(timer);
-            timer = setTimeout(function() {
-                sentEvents = {};
-            }, 0);
-        };
-        return sendEventForHits;
-    }
-    function createBindEventForHits(param) {
-        var helper = param.helper, widgetType = param.widgetType, instantSearchInstance = param.instantSearchInstance;
-        var bindEventForHits = function bindEventForHits() {
-            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                args[_key] = arguments[_key];
-            }
-            var payloads = _buildEventPayloadsForHits({
-                widgetType: widgetType,
-                helper: helper,
-                methodName: 'bindEvent',
-                args: args,
-                instantSearchInstance: instantSearchInstance
-            });
-            return payloads.length ? "data-insights-event=".concat(serializePayload(payloads)) : '';
-        };
-        return bindEventForHits;
-    }
-
-    function addQueryID(hits, queryID) {
-        if (!queryID) {
-            return hits;
-        }
-        return hits.map(function(hit) {
-            return _object_spread_props(_object_spread({}, hit), {
-                __queryID: queryID
-            });
-        });
-    }
-
-    function addAbsolutePosition(hits, page, hitsPerPage) {
-        return hits.map(function(hit, idx) {
-            return _object_spread_props(_object_spread({}, hit), {
-                __position: hitsPerPage * page + idx + 1
-            });
-        });
+        // When <DynamicWidgets> is mounted, a second provider is used above the user-land
+        // <InstantSearchSSRProvider> in `getServerState()`.
+        // To avoid the user's provider overriding the context value with an empty object,
+        // we skip this provider.
+        if (Object.keys(props).length === 0) {
+            return /*#__PURE__*/ React.createElement(React.Fragment, null, children);
+        }
+        return /*#__PURE__*/ React.createElement(InstantSearchSSRContext.Provider, {
+            value: _object_spread_props(_object_spread({}, props), {
+                ssrSearchRef: ssrSearchRef,
+                recommendIdx: recommendIdx
+            })
+        }, children);
     }
 
     var withUsage$p = createDocumentationMessageGenerator({
@@ -11900,6 +12703,7 @@
                     var currentTextPartId;
                     var currentReasoningPartId;
                     var toolRawInputByCallId = {};
+                    var toolRawOutputByCallId = {};
                     // Promise chain for handling tool calls that return promises
                     var pendingToolCall = Promise.resolve();
                     return new Promise(function(resolve) {
@@ -12144,24 +12948,69 @@
                                         }
                                         break;
                                     }
-                                case 'tool-output-available':
+                                case 'data-tool-output-delta':
                                     {
+                                        var _ref3, _ref4;
                                         if (!currentMessage) break;
+                                        var _chunk_data = chunk.data, toolCallId = _chunk_data.toolCallId, toolName1 = _chunk_data.toolName, delta = _chunk_data.delta;
                                         var toolIndex1 = currentMessage.parts.findIndex(function(p) {
-                                            return 'toolCallId' in p && p.toolCallId === chunk.toolCallId;
+                                            return 'toolCallId' in p && p.toolCallId === toolCallId;
+                                        });
+                                        var existingPart1 = toolIndex1 >= 0 ? currentMessage.parts[toolIndex1] : null;
+                                        var previousRawOutput = (_ref3 = (_ref4 = existingPart1 === null || existingPart1 === void 0 ? void 0 : existingPart1.rawOutput) !== null && _ref4 !== void 0 ? _ref4 : toolRawOutputByCallId[toolCallId]) !== null && _ref3 !== void 0 ? _ref3 : '';
+                                        var nextRawOutput = "".concat(previousRawOutput).concat(delta);
+                                        toolRawOutputByCallId[toolCallId] = nextRawOutput;
+                                        var parsedOutput = parseToolInputDelta(nextRawOutput, existingPart1 === null || existingPart1 === void 0 ? void 0 : existingPart1.output);
+                                        var nextToolPart1 = _object_spread_props(_object_spread({}, existingPart1 !== null && existingPart1 !== void 0 ? existingPart1 : {
+                                            type: "tool-".concat(toolName1),
+                                            toolCallId: toolCallId,
+                                            input: undefined
+                                        }), {
+                                            state: 'output-available',
+                                            output: parsedOutput,
+                                            rawOutput: nextRawOutput,
+                                            preliminary: true
                                         });
                                         if (toolIndex1 >= 0) {
-                                            delete toolRawInputByCallId[chunk.toolCallId];
                                             var updatedParts6 = _to_consumable_array(currentMessage.parts);
-                                            var existingPart1 = updatedParts6[toolIndex1];
-                                            updatedParts6[toolIndex1] = _object_spread_props(_object_spread({}, existingPart1), {
+                                            updatedParts6[toolIndex1] = nextToolPart1;
+                                            currentMessage = _object_spread_props(_object_spread({}, currentMessage), {
+                                                parts: updatedParts6
+                                            });
+                                        } else {
+                                            currentMessage = _object_spread_props(_object_spread({}, currentMessage), {
+                                                parts: _to_consumable_array(currentMessage.parts).concat([
+                                                    nextToolPart1
+                                                ])
+                                            });
+                                        }
+                                        _this.state.replaceMessage(currentMessageIndex, currentMessage);
+                                        break;
+                                    }
+                                case 'tool-output-available':
+                                    {
+                                        if (!currentMessage) break;
+                                        var toolIndex2 = currentMessage.parts.findIndex(function(p) {
+                                            return 'toolCallId' in p && p.toolCallId === chunk.toolCallId;
+                                        });
+                                        if (toolIndex2 >= 0) {
+                                            delete toolRawInputByCallId[chunk.toolCallId];
+                                            delete toolRawOutputByCallId[chunk.toolCallId];
+                                            var updatedParts7 = _to_consumable_array(currentMessage.parts);
+                                            var existingPart2 = updatedParts7[toolIndex2];
+                                            // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+                                            existingPart2.rawOutput;
+                                            var rest = _object_without_properties(existingPart2, [
+                                                "rawOutput"
+                                            ]);
+                                            updatedParts7[toolIndex2] = _object_spread_props(_object_spread({}, rest), {
                                                 state: 'output-available',
                                                 output: chunk.output,
                                                 callProviderMetadata: chunk.callProviderMetadata,
                                                 preliminary: chunk.preliminary
                                             });
                                             currentMessage = _object_spread_props(_object_spread({}, currentMessage), {
-                                                parts: updatedParts6
+                                                parts: updatedParts7
                                             });
                                             _this.state.replaceMessage(currentMessageIndex, currentMessage);
                                         }
@@ -12170,22 +13019,30 @@
                                 case 'tool-error':
                                     {
                                         if (!currentMessage) break;
-                                        var toolIndex2 = currentMessage.parts.findIndex(function(p) {
+                                        var toolIndex3 = currentMessage.parts.findIndex(function(p) {
                                             return 'toolCallId' in p && p.toolCallId === chunk.toolCallId;
                                         });
-                                        if (toolIndex2 >= 0) {
+                                        if (toolIndex3 >= 0) {
                                             var _chunk_input;
                                             delete toolRawInputByCallId[chunk.toolCallId];
-                                            var updatedParts7 = _to_consumable_array(currentMessage.parts);
-                                            var existingPart2 = updatedParts7[toolIndex2];
-                                            updatedParts7[toolIndex2] = _object_spread_props(_object_spread({}, existingPart2), {
+                                            delete toolRawOutputByCallId[chunk.toolCallId];
+                                            var updatedParts8 = _to_consumable_array(currentMessage.parts);
+                                            var existingPart3 = updatedParts8[toolIndex3];
+                                            // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+                                            existingPart3.rawOutput; // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+                                            existingPart3.preliminary;
+                                            var rest1 = _object_without_properties(existingPart3, [
+                                                "rawOutput",
+                                                "preliminary"
+                                            ]);
+                                            updatedParts8[toolIndex3] = _object_spread_props(_object_spread({}, rest1), {
                                                 state: 'output-error',
                                                 errorText: chunk.errorText,
-                                                input: (_chunk_input = chunk.input) !== null && _chunk_input !== void 0 ? _chunk_input : existingPart2.input,
+                                                input: (_chunk_input = chunk.input) !== null && _chunk_input !== void 0 ? _chunk_input : existingPart3.input,
                                                 callProviderMetadata: chunk.callProviderMetadata
                                             });
                                             currentMessage = _object_spread_props(_object_spread({}, currentMessage), {
-                                                parts: updatedParts7
+                                                parts: updatedParts8
                                             });
                                             _this.state.replaceMessage(currentMessageIndex, currentMessage);
                                         }
@@ -12560,6 +13417,7 @@
     var MemorizeToolType = 'algolia_memorize';
     var MemorySearchToolType = 'algolia_memory_search';
     var PonderToolType = 'algolia_ponder';
+    var DisplayResultsToolType = 'algolia_display_results';
 
     function flat(arr) {
         return arr.reduce(function(acc, array) {
@@ -12684,236 +13542,60 @@
                             headers: resolvedHeaders,
                             api: _this.api
                         })) : Promise.resolve(null);
-                        return preparePromise.then(function(prepared) {
-                            if (prepared) {
-                                if (prepared.api) api = prepared.api;
-                                if (prepared.headers) {
-                                    headers = _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers;
-                                }
-                                if (prepared.credentials) credentials = prepared.credentials;
-                            }
-                            // GET request for reconnection
-                            return fetchFn("".concat(api, "?chatId=").concat(chatId), {
-                                method: 'GET',
-                                headers: headers,
-                                credentials: credentials
-                            }).then(function(response) {
-                                if (!response.ok) {
-                                    // 404 means no stream to reconnect to, which is not an error
-                                    if (response.status === 404) {
-                                        return null;
-                                    }
-                                    throw new Error("HTTP error: ".concat(response.status, " ").concat(response.statusText));
-                                }
-                                if (!response.body) {
-                                    return null;
-                                }
-                                return _this.processResponseStream(response.body);
-                            });
-                        });
-                    });
-                }
-            }
-        ]);
-        return HttpChatTransport;
-    }();
-    /**
-     * Default chat transport implementation using NDJSON streaming.
-     */ var DefaultChatTransport = /*#__PURE__*/ function(HttpChatTransport) {
-        _inherits(DefaultChatTransport, HttpChatTransport);
-        function DefaultChatTransport() {
-            var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-            _class_call_check(this, DefaultChatTransport);
-            return _call_super(this, DefaultChatTransport, [
-                options
-            ]);
-        }
-        _create_class(DefaultChatTransport, [
-            {
-                key: "processResponseStream",
-                value: function processResponseStream(stream) {
-                    return parseJsonEventStream(stream);
-                }
-            }
-        ]);
-        return DefaultChatTransport;
-    }(HttpChatTransport);
-
-    function sendChatMessageFeedback(param) {
-        var agentId = param.agentId, vote = param.vote, messageId = param.messageId, appId = param.appId, apiKey = param.apiKey;
-        return fetch("https://".concat(appId, ".algolia.net/agent-studio/1/feedback"), {
-            method: 'POST',
-            body: JSON.stringify({
-                messageId: messageId,
-                agentId: agentId,
-                vote: vote
-            }),
-            headers: {
-                'x-algolia-application-id': appId,
-                'x-algolia-api-key': apiKey,
-                'content-type': 'application/json'
-            }
-        }).then(function(response) {
-            if (response.status >= 300) {
-                return response.json().then(function(data) {
-                    throw new Error("Feedback request failed with status ".concat(response.status, ": ").concat(data.message));
-                });
-            }
-            return response.json();
-        });
-    }
-
-    /**
-     * Clears the refinements of a SearchParameters object based on rules provided.
-     * The included attributes list is applied before the excluded attributes list. If the list
-     * is not provided, this list of all the currently refined attributes is used as included attributes.
-     * @returns search parameters with refinements cleared
-     */ function clearRefinements(param) {
-        var helper = param.helper, _param_attributesToClear = param.attributesToClear, attributesToClear = _param_attributesToClear === void 0 ? [] : _param_attributesToClear;
-        var finalState = helper.state.setPage(0);
-        finalState = attributesToClear.reduce(function(state, attribute) {
-            if (finalState.isNumericRefined(attribute)) {
-                return state.removeNumericRefinement(attribute);
-            }
-            if (finalState.isHierarchicalFacet(attribute)) {
-                return state.removeHierarchicalFacetRefinement(attribute);
-            }
-            if (finalState.isDisjunctiveFacet(attribute)) {
-                return state.removeDisjunctiveFacetRefinement(attribute);
-            }
-            if (finalState.isConjunctiveFacet(attribute)) {
-                return state.removeFacetRefinement(attribute);
-            }
-            return state;
-        }, finalState);
-        if (attributesToClear.indexOf('query') !== -1) {
-            finalState = finalState.setQuery('');
-        }
-        return finalState;
-    }
-
-    function unescapeFacetValue(value) {
-        if (typeof value === 'string') {
-            return value.replace(/^\\-/, '-');
-        }
-        return value;
-    }
-    function escapeFacetValue(value) {
-        if (typeof value === 'number' && value < 0 || typeof value === 'string') {
-            return String(value).replace(/^-/, '\\-');
-        }
-        return value;
-    }
-
-    function getRefinement(state, type, attribute, name) {
-        var resultsFacets = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : [];
-        var res = {
-            type: type,
-            attribute: attribute,
-            name: name,
-            escapedValue: escapeFacetValue(name)
-        };
-        var facet = find$1(resultsFacets, function(resultsFacet) {
-            return resultsFacet.name === attribute;
-        });
-        var count;
-        if (type === 'hierarchical') {
-            var _loop = function _loop(i) {
-                facet = facet && facet.data && find$1(Object.keys(facet.data).map(getFacetRefinement(facet.data)), function(refinement) {
-                    return refinement.name === nameParts[i];
-                });
-            };
-            var facetDeclaration = state.getHierarchicalFacetByName(attribute);
-            var nameParts = name.split(facetDeclaration.separator);
-            var getFacetRefinement = function getFacetRefinement(facetData) {
-                return function(refinementKey) {
-                    return facetData[refinementKey];
-                };
-            };
-            for(var i = 0; facet !== undefined && i < nameParts.length; ++i)_loop(i);
-            count = facet && facet.count;
-        } else {
-            count = facet && facet.data && facet.data[res.name];
-        }
-        if (count !== undefined) {
-            res.count = count;
-        }
-        if (facet && facet.exhaustive !== undefined) {
-            res.exhaustive = facet.exhaustive;
-        }
-        return res;
-    }
-    function getRefinements(_results, state) {
-        var includesQuery = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
-        var results = _results || {};
-        var refinements = [];
-        var _state_facetsRefinements = state.facetsRefinements, facetsRefinements = _state_facetsRefinements === void 0 ? {} : _state_facetsRefinements, _state_facetsExcludes = state.facetsExcludes, facetsExcludes = _state_facetsExcludes === void 0 ? {} : _state_facetsExcludes, _state_disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements, disjunctiveFacetsRefinements = _state_disjunctiveFacetsRefinements === void 0 ? {} : _state_disjunctiveFacetsRefinements, _state_hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements, hierarchicalFacetsRefinements = _state_hierarchicalFacetsRefinements === void 0 ? {} : _state_hierarchicalFacetsRefinements, _state_numericRefinements = state.numericRefinements, numericRefinements = _state_numericRefinements === void 0 ? {} : _state_numericRefinements, _state_tagRefinements = state.tagRefinements, tagRefinements = _state_tagRefinements === void 0 ? [] : _state_tagRefinements;
-        Object.keys(facetsRefinements).forEach(function(attribute) {
-            var refinementNames = facetsRefinements[attribute];
-            refinementNames.forEach(function(refinementName) {
-                refinements.push(getRefinement(state, 'facet', attribute, refinementName, results.facets));
-            });
-        });
-        Object.keys(facetsExcludes).forEach(function(attribute) {
-            var refinementNames = facetsExcludes[attribute];
-            refinementNames.forEach(function(refinementName) {
-                refinements.push({
-                    type: 'exclude',
-                    attribute: attribute,
-                    name: refinementName,
-                    exclude: true
-                });
-            });
-        });
-        Object.keys(disjunctiveFacetsRefinements).forEach(function(attribute) {
-            var refinementNames = disjunctiveFacetsRefinements[attribute];
-            refinementNames.forEach(function(refinementName) {
-                refinements.push(getRefinement(state, 'disjunctive', attribute, // they can be escaped on negative numeric values with `escapeFacetValue`.
-                unescapeFacetValue(refinementName), results.disjunctiveFacets));
-            });
-        });
-        Object.keys(hierarchicalFacetsRefinements).forEach(function(attribute) {
-            var refinementNames = hierarchicalFacetsRefinements[attribute];
-            refinementNames.forEach(function(refinement) {
-                refinements.push(getRefinement(state, 'hierarchical', attribute, refinement, results.hierarchicalFacets));
-            });
-        });
-        Object.keys(numericRefinements).forEach(function(attribute) {
-            var operators = numericRefinements[attribute];
-            Object.keys(operators).forEach(function(operatorOriginal) {
-                var operator = operatorOriginal;
-                var valueOrValues = operators[operator];
-                var refinementNames = Array.isArray(valueOrValues) ? valueOrValues : [
-                    valueOrValues
-                ];
-                refinementNames.forEach(function(refinementName) {
-                    refinements.push({
-                        type: 'numeric',
-                        attribute: attribute,
-                        name: "".concat(refinementName),
-                        numericValue: refinementName,
-                        operator: operator
+                        return preparePromise.then(function(prepared) {
+                            if (prepared) {
+                                if (prepared.api) api = prepared.api;
+                                if (prepared.headers) {
+                                    headers = _instanceof(prepared.headers, Headers) ? Object.fromEntries(prepared.headers.entries()) : prepared.headers;
+                                }
+                                if (prepared.credentials) credentials = prepared.credentials;
+                            }
+                            // GET request for reconnection
+                            return fetchFn("".concat(api, "?chatId=").concat(chatId), {
+                                method: 'GET',
+                                headers: headers,
+                                credentials: credentials
+                            }).then(function(response) {
+                                if (!response.ok) {
+                                    // 404 means no stream to reconnect to, which is not an error
+                                    if (response.status === 404) {
+                                        return null;
+                                    }
+                                    throw new Error("HTTP error: ".concat(response.status, " ").concat(response.statusText));
+                                }
+                                if (!response.body) {
+                                    return null;
+                                }
+                                return _this.processResponseStream(response.body);
+                            });
+                        });
                     });
-                });
-            });
-        });
-        tagRefinements.forEach(function(refinementName) {
-            refinements.push({
-                type: 'tag',
-                attribute: '_tags',
-                name: refinementName
-            });
-        });
-        if (includesQuery && state.query && state.query.trim()) {
-            refinements.push({
-                attribute: 'query',
-                type: 'query',
-                name: state.query,
-                query: state.query
-            });
+                }
+            }
+        ]);
+        return HttpChatTransport;
+    }();
+    /**
+     * Default chat transport implementation using NDJSON streaming.
+     */ var DefaultChatTransport = /*#__PURE__*/ function(HttpChatTransport) {
+        _inherits(DefaultChatTransport, HttpChatTransport);
+        function DefaultChatTransport() {
+            var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+            _class_call_check(this, DefaultChatTransport);
+            return _call_super(this, DefaultChatTransport, [
+                options
+            ]);
         }
-        return refinements;
-    }
+        _create_class(DefaultChatTransport, [
+            {
+                key: "processResponseStream",
+                value: function processResponseStream(stream) {
+                    return parseJsonEventStream(stream);
+                }
+            }
+        ]);
+        return DefaultChatTransport;
+    }(HttpChatTransport);
 
     var withUsage$n = createDocumentationMessageGenerator({
         name: 'chat',
@@ -13733,67 +14415,6 @@
         return useConnector(connectFrequentlyBoughtTogether, props, additionalWidgetProperties);
     }
 
-    var latLngRegExp = /^(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)$/;
-    function aroundLatLngToPosition(value) {
-        var pattern = value.match(latLngRegExp);
-        // Since the value provided is the one send with the request, the API should
-        // throw an error due to the wrong format. So throw an error should be safe.
-        if (!pattern) {
-            throw new Error('Invalid value for "aroundLatLng" parameter: "'.concat(value, '"'));
-        }
-        return {
-            lat: parseFloat(pattern[1]),
-            lng: parseFloat(pattern[2])
-        };
-    }
-    function insideBoundingBoxArrayToBoundingBox(value) {
-        var _value = _sliced_to_array(value, 1), tmp = _value[0], _ref = _sliced_to_array(tmp === void 0 ? [
-            undefined,
-            undefined,
-            undefined,
-            undefined
-        ] : tmp, 4), neLat = _ref[0], neLng = _ref[1], swLat = _ref[2], swLng = _ref[3];
-        // Since the value provided is the one send with the request, the API should
-        // throw an error due to the wrong format. So throw an error should be safe.
-        if (!neLat || !neLng || !swLat || !swLng) {
-            throw new Error('Invalid value for "insideBoundingBox" parameter: ['.concat(value, "]"));
-        }
-        return {
-            northEast: {
-                lat: neLat,
-                lng: neLng
-            },
-            southWest: {
-                lat: swLat,
-                lng: swLng
-            }
-        };
-    }
-    function insideBoundingBoxStringToBoundingBox(value) {
-        var _value_split_map = _sliced_to_array(value.split(',').map(parseFloat), 4), neLat = _value_split_map[0], neLng = _value_split_map[1], swLat = _value_split_map[2], swLng = _value_split_map[3];
-        // Since the value provided is the one send with the request, the API should
-        // throw an error due to the wrong format. So throw an error should be safe.
-        if (!neLat || !neLng || !swLat || !swLng) {
-            throw new Error('Invalid value for "insideBoundingBox" parameter: "'.concat(value, '"'));
-        }
-        return {
-            northEast: {
-                lat: neLat,
-                lng: neLng
-            },
-            southWest: {
-                lat: swLat,
-                lng: swLng
-            }
-        };
-    }
-    function insideBoundingBoxToBoundingBox(value) {
-        if (Array.isArray(value)) {
-            return insideBoundingBoxArrayToBoundingBox(value);
-        }
-        return insideBoundingBoxStringToBoundingBox(value);
-    }
-
     var withUsage$j = createDocumentationMessageGenerator({
         name: 'geo-search',
         connector: true
@@ -13991,51 +14612,6 @@
         return useConnector(connectGeoSearch, props, additionalWidgetProperties);
     }
 
-    function isFacetRefined(helper, facet, value) {
-        if (helper.state.isHierarchicalFacet(facet)) {
-            return helper.state.isHierarchicalFacetRefined(facet, value);
-        } else if (helper.state.isConjunctiveFacet(facet)) {
-            return helper.state.isFacetRefined(facet, value);
-        } else {
-            return helper.state.isDisjunctiveFacetRefined(facet, value);
-        }
-    }
-
-    function createSendEventForFacet(param) {
-        var instantSearchInstance = param.instantSearchInstance, helper = param.helper, attr = param.attribute, widgetType = param.widgetType;
-        var sendEventForFacet = function sendEventForFacet() {
-            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                args[_key] = arguments[_key];
-            }
-            var _args = _sliced_to_array(args, 4), facetValue = _args[1], tmp = _args[2], eventName = tmp === void 0 ? 'Filter Applied' : tmp, tmp1 = _args[3], additionalData = tmp1 === void 0 ? {} : tmp1;
-            var _args__split = _sliced_to_array(args[0].split(':'), 2), eventType = _args__split[0], eventModifier = _args__split[1];
-            var attribute = typeof attr === 'string' ? attr : attr(facetValue);
-            if (args.length === 1 && _type_of(args[0]) === 'object') {
-                instantSearchInstance.sendEventToInsights(args[0]);
-            } else if (eventType === 'click' && args.length >= 2 && args.length <= 4) {
-                if (!isFacetRefined(helper, attribute, facetValue)) {
-                    var _helper_lastResults;
-                    // send event only when the facet is being checked "ON"
-                    instantSearchInstance.sendEventToInsights({
-                        insightsMethod: 'clickedFilters',
-                        widgetType: widgetType,
-                        eventType: eventType,
-                        eventModifier: eventModifier,
-                        payload: _object_spread({
-                            eventName: eventName,
-                            index: ((_helper_lastResults = helper.lastResults) === null || _helper_lastResults === void 0 ? void 0 : _helper_lastResults.index) || helper.state.index,
-                            filters: [
-                                "".concat(attribute, ":").concat(facetValue)
-                            ]
-                        }, additionalData),
-                        attribute: attribute
-                    });
-                }
-            } else ;
-        };
-        return sendEventForFacet;
-    }
-
     var withUsage$i = createDocumentationMessageGenerator({
         name: 'hierarchical-menu',
         connector: true
@@ -14492,17 +15068,6 @@
         return useConnector(connectHitsPerPage, props, additionalWidgetProperties);
     }
 
-    /**
-     * Recurse over all child indices
-     */ function walkIndex(indexWidget, callback) {
-        callback(indexWidget);
-        indexWidget.getWidgets().forEach(function(widget) {
-            if (isIndexWidget(widget)) {
-                walkIndex(widget, callback);
-            }
-        });
-    }
-
     var withUsage$f = createDocumentationMessageGenerator({
         name: 'infinite-hits',
         connector: true
@@ -14671,19 +15236,16 @@
                         });
                         /*
                 With dynamic widgets, facets are not included in the state before their relevant widgets are mounted. Until then, we need to bail out of writing this incomplete state representation in cache.
-              */ var hasDynamicWidgets = false;
+              */ var hasTwoPassWidgets = false;
                         walkIndex(instantSearchInstance.mainIndex, function(indexWidget) {
-                            if (!hasDynamicWidgets && indexWidget.getWidgets().some(function(param) {
-                                var $$type = param.$$type;
-                                return $$type === 'ais.dynamicWidgets';
-                            })) {
-                                hasDynamicWidgets = true;
+                            if (!hasTwoPassWidgets && indexWidget.getWidgets().some(isTwoPassWidget)) {
+                                hasTwoPassWidgets = true;
                             }
                         });
                         var hasNoFacets = !((_state_disjunctiveFacets = state.disjunctiveFacets) === null || _state_disjunctiveFacets === void 0 ? void 0 : _state_disjunctiveFacets.length) && !(state.facets || []).filter(function(f) {
                             return f !== '*';
                         }).length && !((_state_hierarchicalFacets = state.hierarchicalFacets) === null || _state_hierarchicalFacets === void 0 ? void 0 : _state_hierarchicalFacets.length);
-                        if (cachedHits[page] === undefined && !results.__isArtificial && instantSearchInstance.status === 'idle' && !(hasDynamicWidgets && hasNoFacets)) {
+                        if (cachedHits[page] === undefined && !results.__isArtificial && instantSearchInstance.status === 'idle' && !(hasTwoPassWidgets && hasNoFacets)) {
                             cachedHits[page] = transformedHits;
                             cache.write({
                                 state: normalizeState(state),
@@ -14944,14 +15506,6 @@
         return useConnector(connectMenu, props, additionalWidgetProperties);
     }
 
-    // This is the `Number.isFinite()` polyfill recommended by MDN.
-    // We do not provide any tests for this function.
-    // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill
-    // @MAJOR Replace with the native `Number.isFinite` method
-    function isFiniteNumber(value) {
-        return typeof value === 'number' && isFinite(value);
-    }
-
     var withUsage$d = createDocumentationMessageGenerator({
         name: 'numeric-menu',
         connector: true
@@ -15212,21 +15766,6 @@
         return useConnector(connectNumericMenu, props, additionalWidgetProperties);
     }
 
-    function range(param) {
-        var _param_start = param.start, start = _param_start === void 0 ? 0 : _param_start, end = param.end, _param_step = param.step, step = _param_step === void 0 ? 1 : _param_step;
-        // We can't divide by 0 so we re-assign the step to 1 if it happens.
-        var limitStep = step === 0 ? 1 : step;
-        // In some cases the array to create has a decimal length.
-        // We therefore need to round the value.
-        // Example:
-        //   { start: 1, end: 5000, step: 500 }
-        //   => Array length = (5000 - 1) / 500 = 9.998
-        var arrayLength = Math.round((end - start) / limitStep);
-        return _to_consumable_array(Array(arrayLength)).map(function(_, current) {
-            return start + current * limitStep;
-        });
-    }
-
     var Paginator = /*#__PURE__*/ function() {
         function Paginator(params) {
             _class_call_check(this, Paginator);
@@ -15403,17 +15942,6 @@
         return useConnector(connectPagination, props, additionalWidgetProperties);
     }
 
-    /**
-     * Logs a warning
-     * This is used to log issues in development environment only.
-     */ var warn = noop;
-
-    function toArray(value) {
-        return Array.isArray(value) ? value : [
-            value
-        ];
-    }
-
     function usePoweredBy() {
         var hostname = safelyRunOnBrowser(function(param) {
             var window = param.window;
@@ -16404,7 +16932,8 @@
                 },
                 getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, param) {
                     var uiState = param.uiState;
-                    var sortByValue = uiState.sortBy || connectorState.initialValue || searchParameters.index;
+                    var isUiStateSortByInItems = !uiState.sortBy || Object.prototype.hasOwnProperty.call(connectorState.itemsLookup, uiState.sortBy);
+                    var sortByValue = (isUiStateSortByInItems ? uiState.sortBy : undefined) || connectorState.initialValue || searchParameters.index;
                     if (isValidStrategy(connectorState.itemsLookup, sortByValue)) {
                         var item = connectorState.itemsLookup[sortByValue];
                         // Strategy-based: set the sortBy parameter for composition API
@@ -17505,13 +18034,19 @@
                 var resultsCount = (searchResults === null || searchResults === void 0 ? void 0 : (_searchResults__rawResults = searchResults._rawResults) === null || _searchResults__rawResults === void 0 ? void 0 : _searchResults__rawResults.length) || 0;
                 var requestParams = resultsCount ? requestParamsList === null || requestParamsList === void 0 ? void 0 : requestParamsList.slice(requestParamsIndex, requestParamsIndex + resultsCount) : [];
                 requestParamsIndex += resultsCount;
-                initialResults[widget.getIndexId()] = _object_spread({}, searchResults && {
+                initialResults[widget.getIndexId()] = _object_spread({}, searchResults && _object_spread({
                     state: _object_spread_props(_object_spread({}, searchResults._state), {
                         clickAnalytics: requestParams === null || requestParams === void 0 ? void 0 : (_requestParams_ = requestParams[0]) === null || _requestParams_ === void 0 ? void 0 : _requestParams_.clickAnalytics,
                         userToken: requestParams === null || requestParams === void 0 ? void 0 : (_requestParams_1 = requestParams[0]) === null || _requestParams_1 === void 0 ? void 0 : _requestParams_1.userToken
                     }),
                     results: searchResults._rawResults
-                }, recommendResults && {
+                }, searchResults.feeds && searchResults.feeds.length > 0 && {
+                    compositionFeedsResults: searchResults.feeds.map(function(feed) {
+                        return _object_spread_props(_object_spread({}, feed._rawResults[0]), {
+                            feedID: feed.feedID
+                        });
+                    })
+                }), recommendResults && {
                     recommendResults: {
                         // We have to stringify + parse because of some explicitly undefined values.
                         params: JSON.parse(JSON.stringify(recommendResults._state.params)),
@@ -17555,12 +18090,9 @@
             notifyServer: createNotifyServer()
         }).then(function(serverState) {
             var shouldRefetch = false;
-            // <DynamicWidgets> requires another query to retrieve the dynamic widgets
-            // to render.
+            // Two-pass widgets require another query to discover and mount child widgets.
             walkIndex(searchRef.current.mainIndex, function(index) {
-                shouldRefetch = shouldRefetch || index.getWidgets().some(function(widget) {
-                    return widget.$$type === 'ais.dynamicWidgets';
-                });
+                shouldRefetch = shouldRefetch || index.getWidgets().some(isTwoPassWidget);
             });
             if (shouldRefetch) {
                 resetWidgetId();
@@ -19150,12 +19682,17 @@
                     }, markdown);
                 }
                 if (startsWith(part.type, 'tool-')) {
+                    var _message_metadata;
                     var toolName = part.type.replace('tool-', '');
                     var tool = tools[toolName];
                     // Compatibility shim with Algolia MCP Server search tool
                     if (!tool && startsWith(toolName, "".concat(SearchIndexToolType, "_"))) {
                         tool = tools[SearchIndexToolType];
                     }
+                    var displayResultsEnabled = ((_message_metadata = message.metadata) === null || _message_metadata === void 0 ? void 0 : _message_metadata.displayResultsEnabled) === true;
+                    if (displayResultsEnabled && tool && tool === tools[SearchIndexToolType]) {
+                        return null;
+                    }
                     if (tool) {
                         var ToolLayoutComponent = tool.layoutComponent;
                         var toolMessage = part;
@@ -20070,6 +20607,53 @@
         };
     }
 
+    var DEFAULT_TRANSLATIONS$1 = {
+        streamingLabel: 'Curating results…'
+    };
+    function createDisplayResultsToolComponent(param) {
+        var createElement = param.createElement, Fragment = param.Fragment;
+        return function DisplayResultsTool(userProps) {
+            var toolProps = userProps.toolProps, GroupCarousel = userProps.groupCarouselComponent, userTranslations = userProps.translations;
+            var message = toolProps.message, sendEvent = toolProps.sendEvent;
+            var translations = _object_spread({}, DEFAULT_TRANSLATIONS$1, userTranslations);
+            var output = message === null || message === void 0 ? void 0 : message.output;
+            var intro = typeof (output === null || output === void 0 ? void 0 : output.intro) === 'string' ? output.intro : undefined;
+            var groups = Array.isArray(output === null || output === void 0 ? void 0 : output.groups) ? output.groups : [];
+            var isStreaming = (message === null || message === void 0 ? void 0 : message.state) === 'output-available' && message.preliminary === true;
+            if (!intro && groups.length === 0) {
+                return /*#__PURE__*/ createElement(Fragment, null);
+            }
+            return /*#__PURE__*/ createElement("div", {
+                className: "ais-ChatToolDisplayResults"
+            }, intro && /*#__PURE__*/ createElement("div", {
+                className: "ais-ChatToolDisplayResults-intro"
+            }, intro), groups.map(function(group, groupIndex) {
+                var results = Array.isArray(group.results) ? group.results.filter(function(r) {
+                    return Boolean(r) && typeof r.objectID === 'string' && r.objectID !== '';
+                }) : [];
+                if (results.length === 0) return null;
+                var items = results.map(function(result, idx) {
+                    return _object_spread_props(_object_spread({}, result), {
+                        __position: idx + 1
+                    });
+                });
+                return /*#__PURE__*/ createElement("div", {
+                    key: groupIndex,
+                    className: "ais-ChatToolDisplayResults-group"
+                }, group.title && /*#__PURE__*/ createElement("div", {
+                    className: "ais-ChatToolDisplayResults-groupTitle"
+                }, group.title), group.why && /*#__PURE__*/ createElement("div", {
+                    className: "ais-ChatToolDisplayResults-groupWhy"
+                }, group.why), /*#__PURE__*/ createElement(GroupCarousel, {
+                    items: items,
+                    sendEvent: sendEvent
+                }));
+            }), isStreaming && /*#__PURE__*/ createElement("div", {
+                className: "ais-ChatToolDisplayResults-streaming"
+            }, translations.streamingLabel));
+        };
+    }
+
     function createDefaultEmptyComponent(param) {
         var createElement = param.createElement, Fragment = param.Fragment;
         return function DefaultEmpty() {
@@ -21960,6 +22544,61 @@
         createElement: React.createElement
     });
 
+    function createDisplayResultsTool(itemComponent) {
+        var DisplayResultsUIComponent = createDisplayResultsToolComponent({
+            createElement: React.createElement,
+            Fragment: React.Fragment
+        });
+        var Button = createButtonComponent({
+            createElement: React.createElement
+        });
+        var DisplayResultsLayoutComponent = function DisplayResultsLayoutComponent(toolProps) {
+            return /*#__PURE__*/ React.createElement(DisplayResultsUIComponent, {
+                toolProps: toolProps,
+                groupCarouselComponent: function groupCarouselComponent(param) {
+                    var items = param.items, sendEvent = param.sendEvent;
+                    return /*#__PURE__*/ React.createElement(Carousel, {
+                        items: items,
+                        itemComponent: itemComponent,
+                        sendEvent: sendEvent,
+                        showNavigation: false,
+                        headerComponent: function headerComponent(param) {
+                            var canScrollLeft = param.canScrollLeft, canScrollRight = param.canScrollRight, scrollLeft = param.scrollLeft, scrollRight = param.scrollRight;
+                            return /*#__PURE__*/ React.createElement("div", {
+                                className: "ais-ChatToolDisplayResultsCarouselHeader"
+                            }, /*#__PURE__*/ React.createElement("div", {
+                                className: "ais-ChatToolDisplayResultsCarouselHeaderCount"
+                            }, items.length, " result", items.length > 1 ? 's' : ''), /*#__PURE__*/ React.createElement("div", {
+                                className: "ais-ChatToolDisplayResultsCarouselHeaderScrollButtons"
+                            }, /*#__PURE__*/ React.createElement(Button, {
+                                variant: "outline",
+                                size: "sm",
+                                iconOnly: true,
+                                onClick: scrollLeft,
+                                disabled: !canScrollLeft,
+                                className: "ais-ChatToolDisplayResultsCarouselHeaderScrollButton"
+                            }, /*#__PURE__*/ React.createElement(ChevronLeftIcon, {
+                                createElement: React.createElement
+                            })), /*#__PURE__*/ React.createElement(Button, {
+                                variant: "outline",
+                                size: "sm",
+                                iconOnly: true,
+                                onClick: scrollRight,
+                                disabled: !canScrollRight,
+                                className: "ais-ChatToolDisplayResultsCarouselHeaderScrollButton"
+                            }, /*#__PURE__*/ React.createElement(ChevronRightIcon, {
+                                createElement: React.createElement
+                            }))));
+                        }
+                    });
+                }
+            });
+        };
+        return {
+            layoutComponent: DisplayResultsLayoutComponent
+        };
+    }
+
     function createCarouselTool(showViewAll, itemComponent, getSearchPageURL) {
         var Button = createButtonComponent({
             createElement: React.createElement
@@ -22058,7 +22697,7 @@
     });
     function createDefaultTools(itemComponent, getSearchPageURL) {
         var _obj;
-        return _obj = {}, _define_property(_obj, SearchIndexToolType$1, createCarouselTool(true, itemComponent, getSearchPageURL)), _define_property(_obj, RecommendToolType, createCarouselTool(false, itemComponent, getSearchPageURL)), _define_property(_obj, MemorizeToolType, {}), _define_property(_obj, MemorySearchToolType, {}), _define_property(_obj, PonderToolType, {}), _obj;
+        return _obj = {}, _define_property(_obj, SearchIndexToolType$1, createCarouselTool(true, itemComponent, getSearchPageURL)), _define_property(_obj, RecommendToolType, createCarouselTool(false, itemComponent, getSearchPageURL)), _define_property(_obj, DisplayResultsToolType, createDisplayResultsTool(itemComponent)), _define_property(_obj, MemorizeToolType, {}), _define_property(_obj, MemorySearchToolType, {}), _define_property(_obj, PonderToolType, {}), _obj;
     }
     function ChatInner(_0, _1) {
         var _ref = [
@@ -24029,8 +24668,10 @@
     exports.ClearRefinements = ClearRefinements;
     exports.Configure = Configure;
     exports.CurrentRefinements = CurrentRefinements;
+    exports.DisplayResultsToolType = DisplayResultsToolType;
     exports.DynamicWidgets = DynamicWidgets;
     exports.EXPERIMENTAL_Autocomplete = EXPERIMENTAL_Autocomplete;
+    exports.Feeds = Feeds;
     exports.FilterSuggestions = FilterSuggestions;
     exports.FrequentlyBoughtTogether = FrequentlyBoughtTogether;
     exports.HierarchicalMenu = HierarchicalMenu;
@@ -24074,6 +24715,7 @@
     exports.useConnector = useConnector;
     exports.useCurrentRefinements = useCurrentRefinements;
     exports.useDynamicWidgets = useDynamicWidgets;
+    exports.useFeeds = useFeeds;
     exports.useFilterSuggestions = useFilterSuggestions;
     exports.useFrequentlyBoughtTogether = useFrequentlyBoughtTogether;
     exports.useGeoSearch = useGeoSearch;