{"version":3,"file":"c89c2b13.js","sources":["../../../node_modules/@babel/runtime/helpers/esm/extends.js","../../../node_modules/history/index.js","../../../node_modules/@shopify/hydrogen/dist/esnext/foundation/useServerProps/use-server-props.js","../../../node_modules/@shopify/hydrogen/dist/esnext/foundation/Router/BrowserRouter.client.js"],"sourcesContent":["export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","import _extends from '@babel/runtime/helpers/esm/extends';\n\n/**\r\n * Actions represent the type of change to a location value.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#action\r\n */\nvar Action;\n\n(function (Action) {\n  /**\r\n   * A POP indicates a change to an arbitrary index in the history stack, such\r\n   * as a back or forward navigation. It does not describe the direction of the\r\n   * navigation, only that the current index changed.\r\n   *\r\n   * Note: This is the default action for newly created history objects.\r\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\r\n   * A PUSH indicates a new entry being added to the history stack, such as when\r\n   * a link is clicked and a new page loads. When this happens, all subsequent\r\n   * entries in the stack are lost.\r\n   */\n\n  Action[\"Push\"] = \"PUSH\";\n  /**\r\n   * A REPLACE indicates the entry at the current index in the history stack\r\n   * being replaced by a new one.\r\n   */\n\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\n\nvar readOnly = process.env.NODE_ENV !== \"production\" ? function (obj) {\n  return Object.freeze(obj);\n} : function (obj) {\n  return obj;\n};\n\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== 'undefined') console.warn(message);\n\n    try {\n      // Welcome to debugging history!\n      //\n      // This error is thrown as a convenience so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n\nvar BeforeUnloadEventType = 'beforeunload';\nvar HashChangeEventType = 'hashchange';\nvar PopStateEventType = 'popstate';\n/**\r\n * Browser history stores the location in regular URLs. This is the standard for\r\n * most web apps, but it requires some configuration on the server to ensure you\r\n * serve the same app at multiple URLs.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\r\n */\n\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options = options,\n      _options$window = _options.window,\n      window = _options$window === void 0 ? document.defaultView : _options$window;\n  var globalHistory = window.history;\n\n  function getIndexAndLocation() {\n    var _window$location = window.location,\n        pathname = _window$location.pathname,\n        search = _window$location.search,\n        hash = _window$location.hash;\n    var state = globalHistory.state || {};\n    return [state.idx, readOnly({\n      pathname: pathname,\n      search: search,\n      hash: hash,\n      state: state.usr || null,\n      key: state.key || 'default'\n    })];\n  }\n\n  var blockedPopTx = null;\n\n  function handlePop() {\n    if (blockedPopTx) {\n      blockers.call(blockedPopTx);\n      blockedPopTx = null;\n    } else {\n      var nextAction = Action.Pop;\n\n      var _getIndexAndLocation = getIndexAndLocation(),\n          nextIndex = _getIndexAndLocation[0],\n          nextLocation = _getIndexAndLocation[1];\n\n      if (blockers.length) {\n        if (nextIndex != null) {\n          var delta = index - nextIndex;\n\n          if (delta) {\n            // Revert the POP\n            blockedPopTx = {\n              action: nextAction,\n              location: nextLocation,\n              retry: function retry() {\n                go(delta * -1);\n              }\n            };\n            go(delta);\n          }\n        } else {\n          // Trying to POP to a location with no index. We did not create\n          // this location, so we can't effectively block the navigation.\n          process.env.NODE_ENV !== \"production\" ? warning(false, // TODO: Write up a doc that explains our blocking strategy in\n          // detail and link to it here so people can understand better what\n          // is going on and how to avoid it.\n          \"You are trying to block a POP navigation to a location that was not \" + \"created by the history library. The block will fail silently in \" + \"production, but in general you should do all navigation with the \" + \"history library (instead of using window.history.pushState directly) \" + \"to avoid this situation.\") : void 0;\n        }\n      } else {\n        applyTx(nextAction);\n      }\n    }\n  }\n\n  window.addEventListener(PopStateEventType, handlePop);\n  var action = Action.Pop;\n\n  var _getIndexAndLocation2 = getIndexAndLocation(),\n      index = _getIndexAndLocation2[0],\n      location = _getIndexAndLocation2[1];\n\n  var listeners = createEvents();\n  var blockers = createEvents();\n\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), '');\n  }\n\n  function createHref(to) {\n    return typeof to === 'string' ? to : createPath(to);\n  } // state defaults to `null` because `window.history.state` does\n\n\n  function getNextLocation(to, state) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    return readOnly(_extends({\n      pathname: location.pathname,\n      hash: '',\n      search: ''\n    }, typeof to === 'string' ? parsePath(to) : to, {\n      state: state,\n      key: createKey()\n    }));\n  }\n\n  function getHistoryStateAndUrl(nextLocation, index) {\n    return [{\n      usr: nextLocation.state,\n      key: nextLocation.key,\n      idx: index\n    }, createHref(nextLocation)];\n  }\n\n  function allowTx(action, location, retry) {\n    return !blockers.length || (blockers.call({\n      action: action,\n      location: location,\n      retry: retry\n    }), false);\n  }\n\n  function applyTx(nextAction) {\n    action = nextAction;\n\n    var _getIndexAndLocation3 = getIndexAndLocation();\n\n    index = _getIndexAndLocation3[0];\n    location = _getIndexAndLocation3[1];\n    listeners.call({\n      action: action,\n      location: location\n    });\n  }\n\n  function push(to, state) {\n    var nextAction = Action.Push;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      push(to, state);\n    }\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1),\n          historyState = _getHistoryStateAndUr[0],\n          url = _getHistoryStateAndUr[1]; // TODO: Support forced reloading\n      // try...catch because iOS limits us to 100 pushState calls :/\n\n\n      try {\n        globalHistory.pushState(historyState, '', url);\n      } catch (error) {\n        // They are going to lose state here, but there is no real\n        // way to warn them about it since the page will refresh...\n        window.location.assign(url);\n      }\n\n      applyTx(nextAction);\n    }\n  }\n\n  function replace(to, state) {\n    var nextAction = Action.Replace;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      replace(to, state);\n    }\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index),\n          historyState = _getHistoryStateAndUr2[0],\n          url = _getHistoryStateAndUr2[1]; // TODO: Support forced reloading\n\n\n      globalHistory.replaceState(historyState, '', url);\n      applyTx(nextAction);\n    }\n  }\n\n  function go(delta) {\n    globalHistory.go(delta);\n  }\n\n  var history = {\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return location;\n    },\n\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    back: function back() {\n      go(-1);\n    },\n    forward: function forward() {\n      go(1);\n    },\n    listen: function listen(listener) {\n      return listeners.push(listener);\n    },\n    block: function block(blocker) {\n      var unblock = blockers.push(blocker);\n\n      if (blockers.length === 1) {\n        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);\n      }\n\n      return function () {\n        unblock(); // Remove the beforeunload listener so the document may\n        // still be salvageable in the pagehide event.\n        // See https://html.spec.whatwg.org/#unloading-documents\n\n        if (!blockers.length) {\n          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);\n        }\n      };\n    }\n  };\n  return history;\n}\n/**\r\n * Hash history stores the location in window.location.hash. This makes it ideal\r\n * for situations where you don't want to send the location to the server for\r\n * some reason, either because you do cannot configure it or the URL space is\r\n * reserved for something else.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\r\n */\n\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options2 = options,\n      _options2$window = _options2.window,\n      window = _options2$window === void 0 ? document.defaultView : _options2$window;\n  var globalHistory = window.history;\n\n  function getIndexAndLocation() {\n    var _parsePath = parsePath(window.location.hash.substr(1)),\n        _parsePath$pathname = _parsePath.pathname,\n        pathname = _parsePath$pathname === void 0 ? '/' : _parsePath$pathname,\n        _parsePath$search = _parsePath.search,\n        search = _parsePath$search === void 0 ? '' : _parsePath$search,\n        _parsePath$hash = _parsePath.hash,\n        hash = _parsePath$hash === void 0 ? '' : _parsePath$hash;\n\n    var state = globalHistory.state || {};\n    return [state.idx, readOnly({\n      pathname: pathname,\n      search: search,\n      hash: hash,\n      state: state.usr || null,\n      key: state.key || 'default'\n    })];\n  }\n\n  var blockedPopTx = null;\n\n  function handlePop() {\n    if (blockedPopTx) {\n      blockers.call(blockedPopTx);\n      blockedPopTx = null;\n    } else {\n      var nextAction = Action.Pop;\n\n      var _getIndexAndLocation4 = getIndexAndLocation(),\n          nextIndex = _getIndexAndLocation4[0],\n          nextLocation = _getIndexAndLocation4[1];\n\n      if (blockers.length) {\n        if (nextIndex != null) {\n          var delta = index - nextIndex;\n\n          if (delta) {\n            // Revert the POP\n            blockedPopTx = {\n              action: nextAction,\n              location: nextLocation,\n              retry: function retry() {\n                go(delta * -1);\n              }\n            };\n            go(delta);\n          }\n        } else {\n          // Trying to POP to a location with no index. We did not create\n          // this location, so we can't effectively block the navigation.\n          process.env.NODE_ENV !== \"production\" ? warning(false, // TODO: Write up a doc that explains our blocking strategy in\n          // detail and link to it here so people can understand better\n          // what is going on and how to avoid it.\n          \"You are trying to block a POP navigation to a location that was not \" + \"created by the history library. The block will fail silently in \" + \"production, but in general you should do all navigation with the \" + \"history library (instead of using window.history.pushState directly) \" + \"to avoid this situation.\") : void 0;\n        }\n      } else {\n        applyTx(nextAction);\n      }\n    }\n  }\n\n  window.addEventListener(PopStateEventType, handlePop); // popstate does not fire on hashchange in IE 11 and old (trident) Edge\n  // https://developer.mozilla.org/de/docs/Web/API/Window/popstate_event\n\n  window.addEventListener(HashChangeEventType, function () {\n    var _getIndexAndLocation5 = getIndexAndLocation(),\n        nextLocation = _getIndexAndLocation5[1]; // Ignore extraneous hashchange events.\n\n\n    if (createPath(nextLocation) !== createPath(location)) {\n      handlePop();\n    }\n  });\n  var action = Action.Pop;\n\n  var _getIndexAndLocation6 = getIndexAndLocation(),\n      index = _getIndexAndLocation6[0],\n      location = _getIndexAndLocation6[1];\n\n  var listeners = createEvents();\n  var blockers = createEvents();\n\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), '');\n  }\n\n  function getBaseHref() {\n    var base = document.querySelector('base');\n    var href = '';\n\n    if (base && base.getAttribute('href')) {\n      var url = window.location.href;\n      var hashIndex = url.indexOf('#');\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n\n    return href;\n  }\n\n  function createHref(to) {\n    return getBaseHref() + '#' + (typeof to === 'string' ? to : createPath(to));\n  }\n\n  function getNextLocation(to, state) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    return readOnly(_extends({\n      pathname: location.pathname,\n      hash: '',\n      search: ''\n    }, typeof to === 'string' ? parsePath(to) : to, {\n      state: state,\n      key: createKey()\n    }));\n  }\n\n  function getHistoryStateAndUrl(nextLocation, index) {\n    return [{\n      usr: nextLocation.state,\n      key: nextLocation.key,\n      idx: index\n    }, createHref(nextLocation)];\n  }\n\n  function allowTx(action, location, retry) {\n    return !blockers.length || (blockers.call({\n      action: action,\n      location: location,\n      retry: retry\n    }), false);\n  }\n\n  function applyTx(nextAction) {\n    action = nextAction;\n\n    var _getIndexAndLocation7 = getIndexAndLocation();\n\n    index = _getIndexAndLocation7[0];\n    location = _getIndexAndLocation7[1];\n    listeners.call({\n      action: action,\n      location: location\n    });\n  }\n\n  function push(to, state) {\n    var nextAction = Action.Push;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      push(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(nextLocation.pathname.charAt(0) === '/', \"Relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr3 = getHistoryStateAndUrl(nextLocation, index + 1),\n          historyState = _getHistoryStateAndUr3[0],\n          url = _getHistoryStateAndUr3[1]; // TODO: Support forced reloading\n      // try...catch because iOS limits us to 100 pushState calls :/\n\n\n      try {\n        globalHistory.pushState(historyState, '', url);\n      } catch (error) {\n        // They are going to lose state here, but there is no real\n        // way to warn them about it since the page will refresh...\n        window.location.assign(url);\n      }\n\n      applyTx(nextAction);\n    }\n  }\n\n  function replace(to, state) {\n    var nextAction = Action.Replace;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      replace(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(nextLocation.pathname.charAt(0) === '/', \"Relative pathnames are not supported in hash history.replace(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr4 = getHistoryStateAndUrl(nextLocation, index),\n          historyState = _getHistoryStateAndUr4[0],\n          url = _getHistoryStateAndUr4[1]; // TODO: Support forced reloading\n\n\n      globalHistory.replaceState(historyState, '', url);\n      applyTx(nextAction);\n    }\n  }\n\n  function go(delta) {\n    globalHistory.go(delta);\n  }\n\n  var history = {\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return location;\n    },\n\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    back: function back() {\n      go(-1);\n    },\n    forward: function forward() {\n      go(1);\n    },\n    listen: function listen(listener) {\n      return listeners.push(listener);\n    },\n    block: function block(blocker) {\n      var unblock = blockers.push(blocker);\n\n      if (blockers.length === 1) {\n        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);\n      }\n\n      return function () {\n        unblock(); // Remove the beforeunload listener so the document may\n        // still be salvageable in the pagehide event.\n        // See https://html.spec.whatwg.org/#unloading-documents\n\n        if (!blockers.length) {\n          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);\n        }\n      };\n    }\n  };\n  return history;\n}\n/**\r\n * Memory history stores the current location in memory. It is designed for use\r\n * in stateful non-browser environments like tests and React Native.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#creatememoryhistory\r\n */\n\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options3 = options,\n      _options3$initialEntr = _options3.initialEntries,\n      initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,\n      initialIndex = _options3.initialIndex;\n  var entries = initialEntries.map(function (entry) {\n    var location = readOnly(_extends({\n      pathname: '/',\n      search: '',\n      hash: '',\n      state: null,\n      key: createKey()\n    }, typeof entry === 'string' ? parsePath(entry) : entry));\n    process.env.NODE_ENV !== \"production\" ? warning(location.pathname.charAt(0) === '/', \"Relative pathnames are not supported in createMemoryHistory({ initialEntries }) (invalid entry: \" + JSON.stringify(entry) + \")\") : void 0;\n    return location;\n  });\n  var index = clamp(initialIndex == null ? entries.length - 1 : initialIndex, 0, entries.length - 1);\n  var action = Action.Pop;\n  var location = entries[index];\n  var listeners = createEvents();\n  var blockers = createEvents();\n\n  function createHref(to) {\n    return typeof to === 'string' ? to : createPath(to);\n  }\n\n  function getNextLocation(to, state) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    return readOnly(_extends({\n      pathname: location.pathname,\n      search: '',\n      hash: ''\n    }, typeof to === 'string' ? parsePath(to) : to, {\n      state: state,\n      key: createKey()\n    }));\n  }\n\n  function allowTx(action, location, retry) {\n    return !blockers.length || (blockers.call({\n      action: action,\n      location: location,\n      retry: retry\n    }), false);\n  }\n\n  function applyTx(nextAction, nextLocation) {\n    action = nextAction;\n    location = nextLocation;\n    listeners.call({\n      action: action,\n      location: location\n    });\n  }\n\n  function push(to, state) {\n    var nextAction = Action.Push;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      push(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(location.pathname.charAt(0) === '/', \"Relative pathnames are not supported in memory history.push(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      applyTx(nextAction, nextLocation);\n    }\n  }\n\n  function replace(to, state) {\n    var nextAction = Action.Replace;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      replace(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(location.pathname.charAt(0) === '/', \"Relative pathnames are not supported in memory history.replace(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      entries[index] = nextLocation;\n      applyTx(nextAction, nextLocation);\n    }\n  }\n\n  function go(delta) {\n    var nextIndex = clamp(index + delta, 0, entries.length - 1);\n    var nextAction = Action.Pop;\n    var nextLocation = entries[nextIndex];\n\n    function retry() {\n      go(delta);\n    }\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      index = nextIndex;\n      applyTx(nextAction, nextLocation);\n    }\n  }\n\n  var history = {\n    get index() {\n      return index;\n    },\n\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return location;\n    },\n\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    back: function back() {\n      go(-1);\n    },\n    forward: function forward() {\n      go(1);\n    },\n    listen: function listen(listener) {\n      return listeners.push(listener);\n    },\n    block: function block(blocker) {\n      return blockers.push(blocker);\n    }\n  };\n  return history;\n} ////////////////////////////////////////////////////////////////////////////////\n// UTILS\n////////////////////////////////////////////////////////////////////////////////\n\nfunction clamp(n, lowerBound, upperBound) {\n  return Math.min(Math.max(n, lowerBound), upperBound);\n}\n\nfunction promptBeforeUnload(event) {\n  // Cancel the event.\n  event.preventDefault(); // Chrome (and legacy IE) requires returnValue to be set.\n\n  event.returnValue = '';\n}\n\nfunction createEvents() {\n  var handlers = [];\n  return {\n    get length() {\n      return handlers.length;\n    },\n\n    push: function push(fn) {\n      handlers.push(fn);\n      return function () {\n        handlers = handlers.filter(function (handler) {\n          return handler !== fn;\n        });\n      };\n    },\n    call: function call(arg) {\n      handlers.forEach(function (fn) {\n        return fn && fn(arg);\n      });\n    }\n  };\n}\n\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\r\n * Creates a string URL path from the given pathname, search, and hash components.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createpath\r\n */\n\n\nfunction createPath(_ref) {\n  var _ref$pathname = _ref.pathname,\n      pathname = _ref$pathname === void 0 ? '/' : _ref$pathname,\n      _ref$search = _ref.search,\n      search = _ref$search === void 0 ? '' : _ref$search,\n      _ref$hash = _ref.hash,\n      hash = _ref$hash === void 0 ? '' : _ref$hash;\n  if (search && search !== '?') pathname += search.charAt(0) === '?' ? search : '?' + search;\n  if (hash && hash !== '#') pathname += hash.charAt(0) === '#' ? hash : '#' + hash;\n  return pathname;\n}\n/**\r\n * Parses a string URL path into its separate pathname, search, and hash components.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#parsepath\r\n */\n\nfunction parsePath(path) {\n  var parsedPath = {};\n\n  if (path) {\n    var hashIndex = path.indexOf('#');\n\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    var searchIndex = path.indexOf('?');\n\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\n\nexport { Action, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, parsePath };\n//# sourceMappingURL=index.js.map\n","import { useContext } from 'react';\nimport { ServerPropsContext, } from '../ServerPropsProvider/ServerPropsProvider.js';\n/**\n * The `useServerProps` hook allows you to manage the [server props](https://shopify.dev/custom-storefronts/hydrogen/framework/server-props) passed to your server components when using Hydrogen as a React Server Component framework. The server props get cleared when you navigate from one route to another.\n *\n * ## Return value\n *\n * The `useServerProps` hook returns an object with the following keys:\n *\n * | Key              | Description                                                                            |\n * | ---------------- | -------------------------------------------------------------------------------------- |\n * | `serverProps`    | The current server props.                                                              |\n * | `setServerProps` | A function used to modify server props.                                                |\n * | `pending`        | Whether a [transition is pending](https://github.com/reactwg/react-18/discussions/41). |\n *\n */\nexport function useServerProps() {\n    const internalServerPropsContext = useContext(ServerPropsContext);\n    if (!internalServerPropsContext) {\n        return {};\n    }\n    return {\n        serverProps: internalServerPropsContext.serverProps,\n        setServerProps: internalServerPropsContext.setServerProps,\n        pending: internalServerPropsContext.pending,\n    };\n}\n/**\n * Internal-only hook to manage server state, including to set location server state\n * @internal\n */\nexport function useInternalServerProps() {\n    return (useContext(ServerPropsContext) ??\n        {});\n}\n","import { createBrowserHistory } from 'history';\nimport React, { createContext, useContext, useMemo, useState, useEffect, useLayoutEffect, useCallback, } from 'react';\nimport { META_ENV_SSR } from '../ssr-interop.js';\nimport { useInternalServerProps } from '../useServerProps/use-server-props.js';\nexport const RouterContext = createContext(undefined);\nlet isFirstLoad = true;\nconst positions = {};\nexport const BrowserRouter = ({ history: pHistory, children }) => {\n    if (META_ENV_SSR)\n        return React.createElement(React.Fragment, null, children);\n    /* eslint-disable react-hooks/rules-of-hooks */\n    const history = useMemo(() => pHistory || createBrowserHistory(), [pHistory]);\n    const [location, setLocation] = useState(history.location);\n    const [scrollNeedsRestoration, setScrollNeedsRestoration] = useState(false);\n    const { pending, locationServerProps, setLocationServerProps } = useInternalServerProps();\n    useScrollRestoration({\n        location,\n        pending,\n        serverProps: locationServerProps,\n        scrollNeedsRestoration,\n        onFinishNavigating: () => setScrollNeedsRestoration(false),\n    });\n    useLayoutEffect(() => {\n        const unlisten = history.listen(({ location: newLocation, action }) => {\n            positions[location.key] = window.scrollY;\n            setLocationServerProps({\n                pathname: newLocation.pathname,\n                search: newLocation.search,\n            });\n            setLocation(newLocation);\n            const state = (newLocation.state ?? {});\n            /**\n             * \"pop\" navigations, like forward/backward buttons, always restore scroll position\n             * regardless of what the original forward navigation intent was.\n             */\n            const needsScrollRestoration = action === 'POP' || !!state.scroll;\n            setScrollNeedsRestoration(needsScrollRestoration);\n        });\n        return () => unlisten();\n    }, [\n        history,\n        location,\n        setScrollNeedsRestoration,\n        setLocation,\n        setLocationServerProps,\n    ]);\n    /* eslint-enable react-hooks/rules-of-hooks */\n    return (React.createElement(RouterContext.Provider, { value: {\n            history,\n            location,\n        } }, children));\n};\nexport function useRouter() {\n    if (META_ENV_SSR)\n        return { location: {}, history: {} };\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    const router = useContext(RouterContext);\n    if (router)\n        return router;\n    throw new Error('Router hooks and <Link> component must be used within a <Router> component');\n}\nexport function useLocation() {\n    return useRouter().location;\n}\n/**\n * Run a callback before browser unload.\n */\nfunction useBeforeUnload(callback) {\n    React.useEffect(() => {\n        window.addEventListener('beforeunload', callback);\n        return () => {\n            window.removeEventListener('beforeunload', callback);\n        };\n    }, [callback]);\n}\nfunction useScrollRestoration({ location, pending, serverProps, scrollNeedsRestoration, onFinishNavigating, }) {\n    /**\n     * Browsers have an API for scroll restoration. We wait for the page to load first,\n     * in case the browser is able to restore scroll position automatically, and then\n     * set it to manual mode.\n     */\n    useEffect(() => {\n        window.history.scrollRestoration = 'manual';\n    }, []);\n    /**\n     * If the page is reloading, allow the browser to handle its own scroll restoration.\n     */\n    useBeforeUnload(useCallback(() => {\n        window.history.scrollRestoration = 'auto';\n    }, []));\n    useLayoutEffect(() => {\n        // The app has just loaded\n        if (isFirstLoad || !scrollNeedsRestoration) {\n            isFirstLoad = false;\n            return;\n        }\n        const position = positions[location.key];\n        /**\n         * When serverState gets updated, `pending` is true while the fetch is in progress.\n         * When that resolves, the serverState is updated. We should wait until the internal\n         * location pointer and serverState match, and pending is false, to do any scrolling.\n         */\n        const finishedNavigating = !pending &&\n            location.pathname === serverProps.pathname &&\n            location.search === serverProps.search;\n        if (!finishedNavigating) {\n            return;\n        }\n        // If there is a location hash, scroll to it\n        if (location.hash) {\n            let element;\n            try {\n                element = document.querySelector(location.hash);\n            }\n            catch (err) {\n                // Do nothing, hash may not be a valid selector\n            }\n            if (element) {\n                element.scrollIntoView();\n                onFinishNavigating();\n                return;\n            }\n        }\n        // If we have a matching position, scroll to it\n        if (position) {\n            window.scrollTo(0, position);\n            onFinishNavigating();\n            return;\n        }\n        // Scroll to the top of new pages\n        window.scrollTo(0, 0);\n        onFinishNavigating();\n    }, [\n        location.pathname,\n        location.search,\n        location.hash,\n        location.key,\n        pending,\n        serverProps.pathname,\n        serverProps.search,\n        scrollNeedsRestoration,\n        onFinishNavigating,\n    ]);\n}\n"],"names":["_extends","target","i","source","key","Action","readOnly","obj","BeforeUnloadEventType","PopStateEventType","createBrowserHistory","options","_options","_options$window","window","globalHistory","getIndexAndLocation","_window$location","pathname","search","hash","state","blockedPopTx","handlePop","blockers","nextAction","_getIndexAndLocation","nextIndex","nextLocation","delta","index","go","applyTx","action","_getIndexAndLocation2","location","listeners","createEvents","createHref","to","createPath","getNextLocation","parsePath","createKey","getHistoryStateAndUrl","allowTx","retry","_getIndexAndLocation3","push","_getHistoryStateAndUr","historyState","url","replace","_getHistoryStateAndUr2","history","listener","blocker","unblock","promptBeforeUnload","event","handlers","fn","handler","arg","_ref","_ref$pathname","_ref$search","_ref$hash","path","parsedPath","hashIndex","searchIndex","useServerProps","internalServerPropsContext","useContext","ServerPropsContext","useInternalServerProps","RouterContext","createContext","undefined","isFirstLoad","positions","BrowserRouter","pHistory","children","useMemo","setLocation","useState","scrollNeedsRestoration","setScrollNeedsRestoration","pending","locationServerProps","setLocationServerProps","useScrollRestoration","serverProps","onFinishNavigating","useLayoutEffect","unlisten","listen","newLocation","scrollY","needsScrollRestoration","scroll","_jsx","useRouter","META_ENV_SSR","router","Error","useLocation","useBeforeUnload","callback","React","useEffect","addEventListener","removeEventListener","scrollRestoration","useCallback","position","element","document","querySelector","scrollIntoView","scrollTo"],"mappings":"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"}