@sonic-equipment/ui 0.0.119 → 1.0.0

package/dist/node_modules/.pnpm/@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/invariant.js

@@ -0,0 +1,15 @@
+/**
+ * Throws an error if the condition is not met in development mode.
+ * This is used to make development a better experience to provide guidance as
+ * to where the error comes from.
+ */
+function invariant(condition, message) {
+  if (!(process.env.NODE_ENV !== 'production')) {
+    return;
+  }
+  if (!condition) {
+    throw new Error("[Autocomplete] ".concat(typeof message === 'function' ? message() : message));
+  }
+}
+
+export { invariant };

package/dist/node_modules/.pnpm/@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/isEqual.js

@@ -0,0 +1,26 @@
+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;
+  }
+  for (var _i = 0, _Object$keys = Object.keys(first); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    if (!(key in second)) {
+      return false;
+    }
+    if (!isEqual(first[key], second[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export { isEqual };

package/dist/node_modules/.pnpm/@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/noop.js

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

package/dist/node_modules/.pnpm/@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/safelyRunOnBrowser.js

@@ -0,0 +1,13 @@
+/**
+ * Safely runs code meant for browser environments only.
+ */
+function safelyRunOnBrowser(callback) {
+  if (typeof window !== 'undefined') {
+    return callback({
+      window: window
+    });
+  }
+  return undefined;
+}
+
+export { safelyRunOnBrowser };

package/dist/node_modules/.pnpm/@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/userAgents.js

@@ -0,0 +1,8 @@
+import { version } from './version.js';
+
+var userAgents = [{
+  segment: 'autocomplete-core',
+  version: version
+}];
+
+export { userAgents };

package/dist/node_modules/.pnpm/@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/version.js

@@ -0,0 +1,3 @@
+var version = '1.19.2';
+
+export { version };

package/dist/node_modules/.pnpm/@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/warn.js

@@ -0,0 +1,26 @@
+var warnCache = {
+  current: {}
+};
+
+/**
+ * Logs a warning if the condition is not met.
+ * This is used to log issues in development environment only.
+ */
+function warn(condition, message) {
+  if (!(process.env.NODE_ENV !== 'production')) {
+    return;
+  }
+  if (condition) {
+    return;
+  }
+  var sanitizedMessage = message.trim();
+  var hasAlreadyPrinted = warnCache.current[sanitizedMessage];
+  if (!hasAlreadyPrinted) {
+    warnCache.current[sanitizedMessage] = true;
+
+    // eslint-disable-next-line no-console
+    console.warn("[Autocomplete] ".concat(sanitizedMessage));
+  }
+}
+
+export { warn, warnCache };

package/dist/node_modules/.pnpm/instantsearch.js@4.79.2_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(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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.79.2_algoliasearch@4.24.0/node_modules/instantsearch.js/es/lib/stateMappings/simple.js

@@ -0,0 +1,36 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _excluded = ["configure"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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.79.2_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.79.2_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.79.2_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.79.2_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 };