@sonic-equipment/ui 0.0.119 → 120.0.0

package/dist/modals/modal/modal.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { ModalOverlay, Modal as Modal$1 } from 'react-aria-components';
+import clsx from 'clsx';
+import { IconButton } from '../../buttons/icon-button/icon-button.js';
+import { StrokeCloseboxIcon } from '../../icons/stroke/stroke-closebox-icon.js';
+import styles from './modal.module.css.js';
+
+const getDocument = () => typeof window === 'undefined' ? undefined : window.document;
+function Modal({ children, className, hasCloseButton, isDismissable, isFullScreen, isKeyboardDismissDisabled, isOpen, onOpenChange, shouldCloseOnInteractOutside = true, }) {
+    const document = getDocument();
+    if (!document)
+        return;
+    return (jsx(ModalOverlay, { ref: ref => {
+            ref?.addEventListener('click', e => {
+                if ((!e.target || ref.contains(e.target)) &&
+                    ref !== e.target)
+                    return;
+                e.preventDefault();
+                e.stopPropagation();
+            });
+            ref?.addEventListener('touchend', e => {
+                if ((!e.target || ref.contains(e.target)) &&
+                    ref !== e.target)
+                    return;
+                e.preventDefault();
+                e.stopPropagation();
+            });
+        }, className: clsx(styles['modal-overlay'], typeof className === 'string' ? className : className?.overlay), isDismissable: isDismissable, isKeyboardDismissDisabled: isKeyboardDismissDisabled, isOpen: isOpen, onOpenChange: onOpenChange, shouldCloseOnInteractOutside: () => shouldCloseOnInteractOutside, UNSTABLE_portalContainer: document.body, children: jsxs(Modal$1, { className: clsx(styles.modal, {
+                [styles['is-full-screen']]: isFullScreen,
+            }, typeof className === 'string' ? undefined : className?.modal), children: [hasCloseButton && (jsx("div", { className: clsx(styles.close, typeof className === 'string' ? className : className?.close), children: jsx(IconButton, { color: "secondary", isDisabled: !isDismissable, onClick: () => onOpenChange?.(false), children: jsx(StrokeCloseboxIcon, {}) }) })), jsx("div", { className: clsx(styles.content, typeof className === 'string' ? className : className?.content), children: children })] }) }));
+}
+
+export { Modal };

package/dist/modals/modal/modal.module.css.js

@@ -0,0 +1,3 @@
+var styles = {"modal-overlay":"modal-module-rVFJc","modal-fade":"modal-module-63Uyl","is-full-screen":"modal-module-uwets","modal":"modal-module-6vlFt","content":"modal-module-FJxzx","modal-slide":"modal-module-jkAe7","modal-delayed-fade":"modal-module-WOZ01","close":"modal-module-7zIZE","modal-zoom":"modal-module-aPJ7X"};
+
+export { styles as default };

package/dist/modals/signin/sign-in-dialog.js

@@ -0,0 +1,22 @@
+"use client";
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { SolidOkayIcon } from '../../icons/solid/solid-okay-icon.js';
+import { FormattedMessage } from '../../intl/formatted-message.js';
+import { useFormattedMessage } from '../../intl/use-formatted-message.js';
+import { List, ListItem } from '../../lists/ul/list.js';
+import { useFavorite } from '../../shared/providers/favorite-provider.js';
+import { RouteButton } from '../../shared/routing/route-button.js';
+import { Dialog } from '../dialog/dialog.js';
+import styles from './sign-in-dialog.module.css.js';
+
+const getLocation = () => typeof window === 'undefined' ? undefined : window.location;
+function SignInDialog({ isOpen, onOpenChange }) {
+    const { signInUrl } = useFavorite();
+    const t = useFormattedMessage();
+    const location = getLocation();
+    if (!location)
+        return null;
+    return (jsx(Dialog, { isDismissable: true, className: { dialog: styles['sign-in-dialog'] }, footer: jsxs(Fragment, { children: [jsx(RouteButton, { withArrow: true, color: "primary", href: `${signInUrl}?returnUrl=${encodeURIComponent(location.pathname + location.search)}`, onClick: () => onOpenChange(false), variant: "solid", children: jsx(FormattedMessage, { id: "sign in" }) }), jsx(RouteButton, { color: "secondary", href: `${signInUrl}?returnUrl=${encodeURIComponent(location.pathname + location.search)}`, onClick: () => onOpenChange(false), variant: "outline", children: jsx(FormattedMessage, { id: "create account" }) })] }), isOpen: isOpen, onOpenChange: onOpenChange, title: t('Shop more efficiently and quicker with a favorites list'), children: jsxs(List, { children: [jsx(ListItem, { icon: jsx(SolidOkayIcon, { fill: "var(--color-status-available)" }), text: t('Easily add your favorite products') }), jsx(ListItem, { icon: jsx(SolidOkayIcon, { fill: "var(--color-status-available)" }), text: t('Your favorites are available on multiple devices') }), jsx(ListItem, { icon: jsx(SolidOkayIcon, { fill: "var(--color-status-available)" }), text: t('Share your favorite list with others') })] }) }));
+}
+
+export { SignInDialog };

package/dist/modals/signin/sign-in-dialog.module.css.js

@@ -0,0 +1,3 @@
+var styles = {"sign-in-dialog":"sign-in-dialog-module-P-AHV"};
+
+export { styles as default };

package/dist/node_modules/.pnpm/instantsearch.js@4.75.4_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/routers/history.js

@@ -0,0 +1,341 @@
+import qs from '../../../../../../../../_virtual/index.js';
+import { safelyRunOnBrowser } from '../utils/safelyRunOnBrowser.js';
+import { createDocumentationLink } from '../utils/documentation.js';
+import { warning as _warning } from '../utils/logger.js';
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var setWindowTitle = function setWindowTitle(title) {
+  if (title) {
+    // This function is only executed on browsers so we can disable this check.
+    // eslint-disable-next-line no-restricted-globals
+    window.document.title = title;
+  }
+};
+var BrowserHistory = /*#__PURE__*/function () {
+  /**
+   * Initializes a new storage provider that syncs the search state to the URL
+   * using web APIs (`window.location.pushState` and `onpopstate` event).
+   */
+  function BrowserHistory(_ref) {
+    var _this = this;
+    var windowTitle = _ref.windowTitle,
+      _ref$writeDelay = _ref.writeDelay,
+      writeDelay = _ref$writeDelay === void 0 ? 400 : _ref$writeDelay,
+      createURL = _ref.createURL,
+      parseURL = _ref.parseURL,
+      getLocation = _ref.getLocation,
+      start = _ref.start,
+      dispose = _ref.dispose,
+      push = _ref.push,
+      cleanUrlOnDispose = _ref.cleanUrlOnDispose;
+    _classCallCheck(this, BrowserHistory);
+    _defineProperty(this, "$$type", 'ais.browser');
+    /**
+     * Transforms a UI state into a title for the page.
+     */
+    _defineProperty(this, "windowTitle", void 0);
+    /**
+     * Time in milliseconds before performing a write in the history.
+     * It prevents from adding too many entries in the history and
+     * makes the back button more usable.
+     *
+     * @default 400
+     */
+    _defineProperty(this, "writeDelay", void 0);
+    /**
+     * Creates a full URL based on the route state.
+     * The storage adaptor maps all syncable keys to the query string of the URL.
+     */
+    _defineProperty(this, "_createURL", void 0);
+    /**
+     * Parses the URL into a route state.
+     * It should be symmetrical to `createURL`.
+     */
+    _defineProperty(this, "parseURL", void 0);
+    /**
+     * Returns the location to store in the history.
+     * @default () => window.location
+     */
+    _defineProperty(this, "getLocation", void 0);
+    _defineProperty(this, "writeTimer", void 0);
+    _defineProperty(this, "_onPopState", void 0);
+    /**
+     * Indicates if last action was back/forward in the browser.
+     */
+    _defineProperty(this, "inPopState", false);
+    /**
+     * Indicates whether the history router is disposed or not.
+     */
+    _defineProperty(this, "isDisposed", false);
+    /**
+     * Indicates the window.history.length before the last call to
+     * window.history.pushState (called in `write`).
+     * It allows to determine if a `pushState` has been triggered elsewhere,
+     * and thus to prevent the `write` method from calling `pushState`.
+     */
+    _defineProperty(this, "latestAcknowledgedHistory", 0);
+    _defineProperty(this, "_start", void 0);
+    _defineProperty(this, "_dispose", void 0);
+    _defineProperty(this, "_push", void 0);
+    _defineProperty(this, "_cleanUrlOnDispose", void 0);
+    this.windowTitle = windowTitle;
+    this.writeTimer = undefined;
+    this.writeDelay = writeDelay;
+    this._createURL = createURL;
+    this.parseURL = parseURL;
+    this.getLocation = getLocation;
+    this._start = start;
+    this._dispose = dispose;
+    this._push = push;
+    this._cleanUrlOnDispose = typeof cleanUrlOnDispose === 'undefined' ? true : cleanUrlOnDispose;
+    if (process.env.NODE_ENV === 'development' && typeof cleanUrlOnDispose === 'undefined') {
+      // eslint-disable-next-line no-console
+      console.info("Starting from the next major version, InstantSearch will not clean up the URL from active refinements when it is disposed.\n\nWe recommend setting `cleanUrlOnDispose` to false to adopt this change today.\nTo stay with the current behaviour and remove this warning, set the option to true.\n\nSee documentation: ".concat(createDocumentationLink({
+        name: 'history-router'
+      }), "#widget-param-cleanurlondispose"));
+    }
+    safelyRunOnBrowser(function (_ref2) {
+      var window = _ref2.window;
+      var title = _this.windowTitle && _this.windowTitle(_this.read());
+      setWindowTitle(title);
+      _this.latestAcknowledgedHistory = window.history.length;
+    });
+  }
+
+  /**
+   * Reads the URL and returns a syncable UI search state.
+   */
+  _createClass(BrowserHistory, [{
+    key: "read",
+    value: function read() {
+      return this.parseURL({
+        qsModule: qs,
+        location: this.getLocation()
+      });
+    }
+
+    /**
+     * Pushes a search state into the URL.
+     */
+  }, {
+    key: "write",
+    value: function write(routeState) {
+      var _this2 = this;
+      safelyRunOnBrowser(function (_ref3) {
+        var window = _ref3.window;
+        var url = _this2.createURL(routeState);
+        var title = _this2.windowTitle && _this2.windowTitle(routeState);
+        if (_this2.writeTimer) {
+          clearTimeout(_this2.writeTimer);
+        }
+        _this2.writeTimer = setTimeout(function () {
+          setWindowTitle(title);
+          if (_this2.shouldWrite(url)) {
+            if (_this2._push) {
+              _this2._push(url);
+            } else {
+              window.history.pushState(routeState, title || '', url);
+            }
+            _this2.latestAcknowledgedHistory = window.history.length;
+          }
+          _this2.inPopState = false;
+          _this2.writeTimer = undefined;
+        }, _this2.writeDelay);
+      });
+    }
+
+    /**
+     * Sets a callback on the `onpopstate` event of the history API of the current page.
+     * It enables the URL sync to keep track of the changes.
+     */
+  }, {
+    key: "onUpdate",
+    value: function onUpdate(callback) {
+      var _this3 = this;
+      if (this._start) {
+        this._start(function () {
+          callback(_this3.read());
+        });
+      }
+      this._onPopState = function () {
+        if (_this3.writeTimer) {
+          clearTimeout(_this3.writeTimer);
+          _this3.writeTimer = undefined;
+        }
+        _this3.inPopState = true;
+
+        // We always read the state from the URL because the state of the history
+        // can be incorect in some cases (e.g. using React Router).
+        callback(_this3.read());
+      };
+      safelyRunOnBrowser(function (_ref4) {
+        var window = _ref4.window;
+        window.addEventListener('popstate', _this3._onPopState);
+      });
+    }
+
+    /**
+     * Creates a complete URL from a given syncable UI state.
+     *
+     * It always generates the full URL, not a relative one.
+     * This allows to handle cases like using a <base href>.
+     * See: https://github.com/algolia/instantsearch/issues/790
+     */
+  }, {
+    key: "createURL",
+    value: function createURL(routeState) {
+      var url = this._createURL({
+        qsModule: qs,
+        routeState: routeState,
+        location: this.getLocation()
+      });
+      if (process.env.NODE_ENV === 'development') {
+        try {
+          // We just want to check if the URL is valid.
+          // eslint-disable-next-line no-new
+          new URL(url);
+        } catch (e) {
+          process.env.NODE_ENV === 'development' ? _warning(false, "The URL returned by the `createURL` function is invalid.\nPlease make sure it returns an absolute URL to avoid issues, e.g: `https://algolia.com/search?query=iphone`.") : void 0;
+        }
+      }
+      return url;
+    }
+
+    /**
+     * Removes the event listener and cleans up the URL.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      var _this4 = this;
+      if (this._dispose) {
+        this._dispose();
+      }
+      this.isDisposed = true;
+      safelyRunOnBrowser(function (_ref5) {
+        var window = _ref5.window;
+        if (_this4._onPopState) {
+          window.removeEventListener('popstate', _this4._onPopState);
+        }
+      });
+      if (this.writeTimer) {
+        clearTimeout(this.writeTimer);
+      }
+      if (this._cleanUrlOnDispose) {
+        this.write({});
+      }
+    }
+  }, {
+    key: "start",
+    value: function start() {
+      this.isDisposed = false;
+    }
+  }, {
+    key: "shouldWrite",
+    value: function shouldWrite(url) {
+      var _this5 = this;
+      return safelyRunOnBrowser(function (_ref6) {
+        var window = _ref6.window;
+        // When disposed and the cleanUrlOnDispose is set to false, we do not want to write the URL.
+        if (_this5.isDisposed && !_this5._cleanUrlOnDispose) {
+          return false;
+        }
+
+        // We do want to `pushState` if:
+        // - the router is not disposed, IS.js needs to update the URL
+        // OR
+        // - the last write was from InstantSearch.js
+        // (unlike a SPA, where it would have last written)
+        var lastPushWasByISAfterDispose = !(_this5.isDisposed && _this5.latestAcknowledgedHistory !== window.history.length);
+        return (
+          // When the last state change was through popstate, the IS.js state changes,
+          // but that should not write the URL.
+          !_this5.inPopState &&
+          // When the previous pushState after dispose was by IS.js, we want to write the URL.
+          lastPushWasByISAfterDispose &&
+          // When the URL is the same as the current one, we do not want to write it.
+          url !== window.location.href
+        );
+      });
+    }
+  }]);
+  return BrowserHistory;
+}();
+function historyRouter() {
+  var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref7$createURL = _ref7.createURL,
+    createURL = _ref7$createURL === void 0 ? function (_ref8) {
+      var qsModule = _ref8.qsModule,
+        routeState = _ref8.routeState,
+        location = _ref8.location;
+      var protocol = location.protocol,
+        hostname = location.hostname,
+        _location$port = location.port,
+        port = _location$port === void 0 ? '' : _location$port,
+        pathname = location.pathname,
+        hash = location.hash;
+      var queryString = qsModule.stringify(routeState);
+      var portWithPrefix = port === '' ? '' : ":".concat(port);
+
+      // IE <= 11 has no proper `location.origin` so we cannot rely on it.
+      if (!queryString) {
+        return "".concat(protocol, "//").concat(hostname).concat(portWithPrefix).concat(pathname).concat(hash);
+      }
+      return "".concat(protocol, "//").concat(hostname).concat(portWithPrefix).concat(pathname, "?").concat(queryString).concat(hash);
+    } : _ref7$createURL,
+    _ref7$parseURL = _ref7.parseURL,
+    parseURL = _ref7$parseURL === void 0 ? function (_ref9) {
+      var qsModule = _ref9.qsModule,
+        location = _ref9.location;
+      // `qs` by default converts arrays with more than 20 items to an object.
+      // We want to avoid this because the data structure manipulated can therefore vary.
+      // Setting the limit to `100` seems a good number because the engine's default is 100
+      // (it can go up to 1000 but it is very unlikely to select more than 100 items in the UI).
+      //
+      // Using an `arrayLimit` of `n` allows `n + 1` items.
+      //
+      // See:
+      //   - https://github.com/ljharb/qs#parsing-arrays
+      //   - https://www.algolia.com/doc/api-reference/api-parameters/maxValuesPerFacet/
+      return qsModule.parse(location.search.slice(1), {
+        arrayLimit: 99
+      });
+    } : _ref7$parseURL,
+    _ref7$writeDelay = _ref7.writeDelay,
+    writeDelay = _ref7$writeDelay === void 0 ? 400 : _ref7$writeDelay,
+    windowTitle = _ref7.windowTitle,
+    _ref7$getLocation = _ref7.getLocation,
+    getLocation = _ref7$getLocation === void 0 ? function () {
+      return safelyRunOnBrowser(function (_ref10) {
+        var window = _ref10.window;
+        return window.location;
+      }, {
+        fallback: function fallback() {
+          throw new Error('You need to provide `getLocation` to the `history` router in environments where `window` does not exist.');
+        }
+      });
+    } : _ref7$getLocation,
+    start = _ref7.start,
+    dispose = _ref7.dispose,
+    push = _ref7.push,
+    cleanUrlOnDispose = _ref7.cleanUrlOnDispose;
+  return new BrowserHistory({
+    createURL: createURL,
+    parseURL: parseURL,
+    writeDelay: writeDelay,
+    windowTitle: windowTitle,
+    getLocation: getLocation,
+    start: start,
+    dispose: dispose,
+    push: push,
+    cleanUrlOnDispose: cleanUrlOnDispose
+  });
+}
+
+export { historyRouter as default };

package/dist/node_modules/.pnpm/instantsearch.js@4.75.4_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/stateMappings/simple.js

@@ -0,0 +1,36 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["configure"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function getIndexStateWithoutConfigure(uiState) {
+  uiState.configure;
+    var trackedUiState = _objectWithoutProperties(uiState, _excluded);
+  return trackedUiState;
+}
+
+// technically a URL could contain any key, since users provide it,
+// which is why the input to this function is UiState, not something
+// which excludes "configure" as this function does.
+function simpleStateMapping() {
+  return {
+    $$type: 'ais.simple',
+    stateToRoute: function stateToRoute(uiState) {
+      return Object.keys(uiState).reduce(function (state, indexId) {
+        return _objectSpread(_objectSpread({}, state), {}, _defineProperty({}, indexId, getIndexStateWithoutConfigure(uiState[indexId])));
+      }, {});
+    },
+    routeToState: function routeToState() {
+      var routeState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return Object.keys(routeState).reduce(function (state, indexId) {
+        return _objectSpread(_objectSpread({}, state), {}, _defineProperty({}, indexId, getIndexStateWithoutConfigure(routeState[indexId])));
+      }, {});
+    }
+  };
+}
+
+export { simpleStateMapping as default };

package/dist/node_modules/.pnpm/instantsearch.js@4.75.4_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/utils/documentation.js

@@ -0,0 +1,8 @@
+function createDocumentationLink(_ref) {
+  var name = _ref.name,
+    _ref$connector = _ref.connector,
+    connector = _ref$connector === void 0 ? false : _ref$connector;
+  return ['https://www.algolia.com/doc/api-reference/widgets/', name, '/js/', connector ? '#connector' : ''].join('');
+}
+
+export { createDocumentationLink };

package/dist/node_modules/.pnpm/instantsearch.js@4.75.4_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/utils/logger.js

@@ -0,0 +1,32 @@
+import { noop } from './noop.js';
+
+/**
+ * Logs a warning
+ * This is used to log issues in development environment only.
+ */
+var warn = noop;
+
+/**
+ * Logs a warning if the condition is not met.
+ * This is used to log issues in development environment only.
+ */
+var _warning = noop;
+if (process.env.NODE_ENV === 'development') {
+  warn = function warn(message) {
+    // eslint-disable-next-line no-console
+    console.warn("[InstantSearch.js]: ".concat(message.trim()));
+  };
+  _warning = function warning(condition, message) {
+    if (condition) {
+      return;
+    }
+    var hasAlreadyPrinted = _warning.cache[message];
+    if (!hasAlreadyPrinted) {
+      _warning.cache[message] = true;
+      process.env.NODE_ENV === 'development' ? warn(message) : void 0;
+    }
+  };
+  _warning.cache = {};
+}
+
+export { warn, _warning as warning };

package/dist/node_modules/.pnpm/instantsearch.js@4.75.4_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/utils/noop.js

@@ -0,0 +1,3 @@
+function noop() {}
+
+export { noop };

package/dist/node_modules/.pnpm/instantsearch.js@4.75.4_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/utils/safelyRunOnBrowser.js

@@ -0,0 +1,24 @@
+// eslint-disable-next-line no-restricted-globals
+
+/**
+ * Runs code on browser environments safely.
+ */
+function safelyRunOnBrowser(callback) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      fallback: function fallback() {
+        return undefined;
+      }
+    },
+    fallback = _ref.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
+  });
+}
+
+export { safelyRunOnBrowser };

package/dist/node_modules/.pnpm/qs@6.9.7/node_modules/qs/lib/formats.js

@@ -0,0 +1,33 @@
+"use strict";
+var formats;
+var hasRequiredFormats;
+
+function requireFormats () {
+	if (hasRequiredFormats) return formats;
+	hasRequiredFormats = 1;
+
+	var replace = String.prototype.replace;
+	var percentTwenties = /%20/g;
+
+	var Format = {
+	    RFC1738: 'RFC1738',
+	    RFC3986: 'RFC3986'
+	};
+
+	formats = {
+	    'default': Format.RFC3986,
+	    formatters: {
+	        RFC1738: function (value) {
+	            return replace.call(value, percentTwenties, '+');
+	        },
+	        RFC3986: function (value) {
+	            return String(value);
+	        }
+	    },
+	    RFC1738: Format.RFC1738,
+	    RFC3986: Format.RFC3986
+	};
+	return formats;
+}
+
+export { requireFormats as __require };

package/dist/node_modules/.pnpm/qs@6.9.7/node_modules/qs/lib/index.js

@@ -0,0 +1,25 @@
+"use strict";
+import { __require as requireStringify } from './stringify.js';
+import { __require as requireParse } from './parse.js';
+import { __require as requireFormats } from './formats.js';
+
+var lib;
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+
+	var stringify = requireStringify();
+	var parse = requireParse();
+	var formats = requireFormats();
+
+	lib = {
+	    formats: formats,
+	    parse: parse,
+	    stringify: stringify
+	};
+	return lib;
+}
+
+export { requireLib as __require };