@qite/tide-booking-component 1.4.41 → 1.4.43

package/build/build-cjs/index.js

@@ -10,8 +10,9 @@ var lodash = require('lodash');
 var locale = require('date-fns/locale');
 var reactPopper = require('react-popper');
 var reactRedux = require('react-redux');
-var router = require('@reach/router');
 var toolkit = require('@reduxjs/toolkit');
+var reactRouter = require('react-router');
+require('react-dom');
 var flat = require('flat');
 var formik = require('formik');
 var produce = require('immer');
@@ -21,6 +22,32 @@ function _interopDefaultLegacy(e) {
   return e && typeof e === 'object' && 'default' in e ? e : { default: e };
 }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(
+          n,
+          k,
+          d.get
+            ? d
+            : {
+                enumerable: true,
+                get: function () {
+                  return e[k];
+                }
+              }
+        );
+      }
+    });
+  }
+  n['default'] = e;
+  return Object.freeze(n);
+}
+
 function _mergeNamespaces(n, m) {
   m.forEach(function (e) {
     e &&
@@ -48,6 +75,7 @@ function _mergeNamespaces(n, m) {
 }
 
 var React__default = /*#__PURE__*/ _interopDefaultLegacy(React);
+var React__namespace = /*#__PURE__*/ _interopNamespace(React);
 var JsonURL__default = /*#__PURE__*/ _interopDefaultLegacy(JsonURL);
 var flat__default = /*#__PURE__*/ _interopDefaultLegacy(flat);
 var produce__default = /*#__PURE__*/ _interopDefaultLegacy(produce);
@@ -15701,6 +15729,802 @@ var BookingProduct = function (_a) {
   );
 };
 
+/**
+ * @remix-run/router v1.23.2
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Types and Constants
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Actions represent the type of change to a location value.
+ */
+var Action;
+(function (Action) {
+  /**
+   * A POP indicates a change to an arbitrary index in the history stack, such
+   * as a back or forward navigation. It does not describe the direction of the
+   * navigation, only that the current index changed.
+   *
+   * Note: This is the default action for newly created history objects.
+   */
+  Action['Pop'] = 'POP';
+  /**
+   * A PUSH indicates a new entry being added to the history stack, such as when
+   * a link is clicked and a new page loads. When this happens, all subsequent
+   * entries in the stack are lost.
+   */
+  Action['Push'] = 'PUSH';
+  /**
+   * A REPLACE indicates the entry at the current index in the history stack
+   * being replaced by a new one.
+   */
+  Action['Replace'] = 'REPLACE';
+})(Action || (Action = {}));
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === 'undefined') {
+    throw new Error(message);
+  }
+}
+function warning(cond, message) {
+  if (!cond) {
+    // eslint-disable-next-line no-console
+    if (typeof console !== 'undefined') console.warn(message);
+    try {
+      // Welcome to debugging history!
+      //
+      // This error is thrown as a convenience, so you can more easily
+      // find the source for a warning that appears in the console by
+      // enabling "pause on exceptions" in your JavaScript debugger.
+      throw new Error(message);
+      // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+}
+//#endregion
+
+var ResultType;
+(function (ResultType) {
+  ResultType['data'] = 'data';
+  ResultType['deferred'] = 'deferred';
+  ResultType['redirect'] = 'redirect';
+  ResultType['error'] = 'error';
+})(ResultType || (ResultType = {}));
+/**
+ * Performs pattern matching on a URL pathname and returns information about
+ * the match.
+ *
+ * @see https://reactrouter.com/v6/utils/match-path
+ */
+function matchPath(pattern, pathname) {
+  if (typeof pattern === 'string') {
+    pattern = {
+      path: pattern,
+      caseSensitive: false,
+      end: true
+    };
+  }
+  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
+  let match = pathname.match(matcher);
+  if (!match) return null;
+  let matchedPathname = match[0];
+  let pathnameBase = matchedPathname.replace(/(.)\/+$/, '$1');
+  let captureGroups = match.slice(1);
+  let params = compiledParams.reduce((memo, _ref, index) => {
+    let { paramName, isOptional } = _ref;
+    // We need to compute the pathnameBase here using the raw splat value
+    // instead of using params["*"] later because it will be decoded then
+    if (paramName === '*') {
+      let splatValue = captureGroups[index] || '';
+      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, '$1');
+    }
+    const value = captureGroups[index];
+    if (isOptional && !value) {
+      memo[paramName] = undefined;
+    } else {
+      memo[paramName] = (value || '').replace(/%2F/g, '/');
+    }
+    return memo;
+  }, {});
+  return {
+    params,
+    pathname: matchedPathname,
+    pathnameBase,
+    pattern
+  };
+}
+function compilePath(path, caseSensitive, end) {
+  if (caseSensitive === void 0) {
+    caseSensitive = false;
+  }
+  if (end === void 0) {
+    end = true;
+  }
+  warning(
+    path === '*' || !path.endsWith('*') || path.endsWith('/*'),
+    'Route path "' +
+      path +
+      '" will be treated as if it were ' +
+      ('"' + path.replace(/\*$/, '/*') + '" because the `*` character must ') +
+      'always follow a `/` in the pattern. To get rid of this warning, ' +
+      ('please change the route path to "' + path.replace(/\*$/, '/*') + '".')
+  );
+  let params = [];
+  let regexpSource =
+    '^' +
+    path
+      .replace(/\/*\*?$/, '') // Ignore trailing / and /*, we'll handle it below
+      .replace(/^\/*/, '/') // Make sure it has a leading /
+      .replace(/[\\.*+^${}|()[\]]/g, '\\$&') // Escape special regex chars
+      .replace(/\/:([\w-]+)(\?)?/g, (_, paramName, isOptional) => {
+        params.push({
+          paramName,
+          isOptional: isOptional != null
+        });
+        return isOptional ? '/?([^\\/]+)?' : '/([^\\/]+)';
+      });
+  if (path.endsWith('*')) {
+    params.push({
+      paramName: '*'
+    });
+    regexpSource +=
+      path === '*' || path === '/*'
+        ? '(.*)$' // Already matched the initial /, just match the rest
+        : '(?:\\/(.+)|\\/*)$'; // Don't include the / in params["*"]
+  } else if (end) {
+    // When matching to the end, ignore trailing slashes
+    regexpSource += '\\/*$';
+  } else if (path !== '' && path !== '/') {
+    // If our path is non-empty and contains anything beyond an initial slash,
+    // then we have _some_ form of path in our regex, so we should expect to
+    // match only if we find the end of this path segment.  Look for an optional
+    // non-captured trailing slash (to match a portion of the URL) or the end
+    // of the path (if we've matched to the end).  We used to do this with a
+    // word boundary but that gives false positives on routes like
+    // /user-preferences since `-` counts as a word boundary.
+    regexpSource += '(?:(?=\\/|$))';
+  } else;
+  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : 'i');
+  return [matcher, params];
+}
+/**
+ * @private
+ */
+function stripBasename(pathname, basename) {
+  if (basename === '/') return pathname;
+  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
+    return null;
+  }
+  // We want to leave trailing slash behavior in the user's control, so if they
+  // specify a basename with a trailing slash, we should support it
+  let startIndex = basename.endsWith('/') ? basename.length - 1 : basename.length;
+  let nextChar = pathname.charAt(startIndex);
+  if (nextChar && nextChar !== '/') {
+    // pathname does not start with basename/
+    return null;
+  }
+  return pathname.slice(startIndex) || '/';
+}
+/**
+ * @private
+ */
+const joinPaths = (paths) => paths.join('/').replace(/\/\/+/g, '/');
+
+const validMutationMethodsArr = ['post', 'put', 'patch', 'delete'];
+['get', ...validMutationMethodsArr];
+
+/**
+ * React Router DOM v6.30.3
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+
+function _extends() {
+  _extends = Object.assign
+    ? Object.assign.bind()
+    : function (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 _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;
+}
+
+const defaultMethod = 'get';
+const defaultEncType = 'application/x-www-form-urlencoded';
+function isHtmlElement(object) {
+  return object != null && typeof object.tagName === 'string';
+}
+function isButtonElement(object) {
+  return isHtmlElement(object) && object.tagName.toLowerCase() === 'button';
+}
+function isFormElement(object) {
+  return isHtmlElement(object) && object.tagName.toLowerCase() === 'form';
+}
+function isInputElement(object) {
+  return isHtmlElement(object) && object.tagName.toLowerCase() === 'input';
+}
+function isModifiedEvent(event) {
+  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
+}
+function shouldProcessLinkClick(event, target) {
+  return (
+    event.button === 0 &&
+    // Ignore everything but left clicks
+    (!target || target === '_self') &&
+    // Let browser handle "target=_blank" etc.
+    !isModifiedEvent(event) // Ignore clicks with modifier keys
+  );
+}
+// One-time check for submitter support
+let _formDataSupportsSubmitter = null;
+function isFormDataSubmitterSupported() {
+  if (_formDataSupportsSubmitter === null) {
+    try {
+      new FormData(
+        document.createElement('form'),
+        // @ts-expect-error if FormData supports the submitter parameter, this will throw
+        0
+      );
+      _formDataSupportsSubmitter = false;
+    } catch (e) {
+      _formDataSupportsSubmitter = true;
+    }
+  }
+  return _formDataSupportsSubmitter;
+}
+const supportedFormEncTypes = new Set(['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain']);
+function getFormEncType(encType) {
+  if (encType != null && !supportedFormEncTypes.has(encType)) {
+    process.env.NODE_ENV !== 'production'
+      ? warning(false, '"' + encType + '" is not a valid `encType` for `<Form>`/`<fetcher.Form>` ' + ('and will default to "' + defaultEncType + '"'))
+      : void 0;
+    return null;
+  }
+  return encType;
+}
+function getFormSubmissionInfo(target, basename) {
+  let method;
+  let action;
+  let encType;
+  let formData;
+  let body;
+  if (isFormElement(target)) {
+    // When grabbing the action from the element, it will have had the basename
+    // prefixed to ensure non-JS scenarios work, so strip it since we'll
+    // re-prefix in the router
+    let attr = target.getAttribute('action');
+    action = attr ? stripBasename(attr, basename) : null;
+    method = target.getAttribute('method') || defaultMethod;
+    encType = getFormEncType(target.getAttribute('enctype')) || defaultEncType;
+    formData = new FormData(target);
+  } else if (isButtonElement(target) || (isInputElement(target) && (target.type === 'submit' || target.type === 'image'))) {
+    let form = target.form;
+    if (form == null) {
+      throw new Error('Cannot submit a <button> or <input type="submit"> without a <form>');
+    }
+    // <button>/<input type="submit"> may override attributes of <form>
+    // When grabbing the action from the element, it will have had the basename
+    // prefixed to ensure non-JS scenarios work, so strip it since we'll
+    // re-prefix in the router
+    let attr = target.getAttribute('formaction') || form.getAttribute('action');
+    action = attr ? stripBasename(attr, basename) : null;
+    method = target.getAttribute('formmethod') || form.getAttribute('method') || defaultMethod;
+    encType = getFormEncType(target.getAttribute('formenctype')) || getFormEncType(form.getAttribute('enctype')) || defaultEncType;
+    // Build a FormData object populated from a form and submitter
+    formData = new FormData(form, target);
+    // If this browser doesn't support the `FormData(el, submitter)` format,
+    // then tack on the submitter value at the end.  This is a lightweight
+    // solution that is not 100% spec compliant.  For complete support in older
+    // browsers, consider using the `formdata-submitter-polyfill` package
+    if (!isFormDataSubmitterSupported()) {
+      let { name, type, value } = target;
+      if (type === 'image') {
+        let prefix = name ? name + '.' : '';
+        formData.append(prefix + 'x', '0');
+        formData.append(prefix + 'y', '0');
+      } else if (name) {
+        formData.append(name, value);
+      }
+    }
+  } else if (isHtmlElement(target)) {
+    throw new Error('Cannot submit element that is not <form>, <button>, or ' + '<input type="submit|image">');
+  } else {
+    method = defaultMethod;
+    action = null;
+    encType = defaultEncType;
+    body = target;
+  }
+  // Send body for <Form encType="text/plain" so we encode it into text
+  if (formData && encType === 'text/plain') {
+    body = formData;
+    formData = undefined;
+  }
+  return {
+    action,
+    method: method.toLowerCase(),
+    encType,
+    formData,
+    body
+  };
+}
+
+const _excluded = ['onClick', 'relative', 'reloadDocument', 'replace', 'state', 'target', 'to', 'preventScrollReset', 'viewTransition'],
+  _excluded2 = ['aria-current', 'caseSensitive', 'className', 'end', 'style', 'to', 'viewTransition', 'children'],
+  _excluded3 = [
+    'fetcherKey',
+    'navigate',
+    'reloadDocument',
+    'replace',
+    'state',
+    'method',
+    'action',
+    'onSubmit',
+    'relative',
+    'preventScrollReset',
+    'viewTransition'
+  ];
+// HEY YOU! DON'T TOUCH THIS VARIABLE!
+//
+// It is replaced with the proper version at build time via a babel plugin in
+// the rollup config.
+//
+// Export a global property onto the window for React Router detection by the
+// Core Web Vitals Technology Report.  This way they can configure the `wappalyzer`
+// to detect and properly classify live websites as being built with React Router:
+// https://github.com/HTTPArchive/wappalyzer/blob/main/src/technologies/r.json
+const REACT_ROUTER_VERSION = '6';
+try {
+  window.__reactRouterVersion = REACT_ROUTER_VERSION;
+} catch (e) {
+  // no-op
+}
+const ViewTransitionContext = /*#__PURE__*/ React__namespace.createContext({
+  isTransitioning: false
+});
+if (process.env.NODE_ENV !== 'production') {
+  ViewTransitionContext.displayName = 'ViewTransition';
+}
+const FetchersContext = /*#__PURE__*/ React__namespace.createContext(new Map());
+if (process.env.NODE_ENV !== 'production') {
+  FetchersContext.displayName = 'Fetchers';
+}
+if (process.env.NODE_ENV !== 'production');
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
+const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+/**
+ * The public API for rendering a history-aware `<a>`.
+ */
+const Link = /*#__PURE__*/ React__namespace.forwardRef(function LinkWithRef(_ref7, ref) {
+  let { onClick, relative, reloadDocument, replace, state, target, to, preventScrollReset, viewTransition } = _ref7,
+    rest = _objectWithoutPropertiesLoose(_ref7, _excluded);
+  let { basename } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext);
+  // Rendered into <a href> for absolute URLs
+  let absoluteHref;
+  let isExternal = false;
+  if (typeof to === 'string' && ABSOLUTE_URL_REGEX.test(to)) {
+    // Render the absolute href server- and client-side
+    absoluteHref = to;
+    // Only check for external origins client-side
+    if (isBrowser) {
+      try {
+        let currentUrl = new URL(window.location.href);
+        let targetUrl = to.startsWith('//') ? new URL(currentUrl.protocol + to) : new URL(to);
+        let path = stripBasename(targetUrl.pathname, basename);
+        if (targetUrl.origin === currentUrl.origin && path != null) {
+          // Strip the protocol/origin/basename for same-origin absolute URLs
+          to = path + targetUrl.search + targetUrl.hash;
+        } else {
+          isExternal = true;
+        }
+      } catch (e) {
+        // We can't do external URL detection without a valid URL
+        process.env.NODE_ENV !== 'production'
+          ? warning(false, '<Link to="' + to + '"> contains an invalid URL which will probably break ' + 'when clicked - please update to a valid URL path.')
+          : void 0;
+      }
+    }
+  }
+  // Rendered into <a href> for relative URLs
+  let href = reactRouter.useHref(to, {
+    relative
+  });
+  let internalOnClick = useLinkClickHandler(to, {
+    replace,
+    state,
+    target,
+    preventScrollReset,
+    relative,
+    viewTransition
+  });
+  function handleClick(event) {
+    if (onClick) onClick(event);
+    if (!event.defaultPrevented) {
+      internalOnClick(event);
+    }
+  }
+  return (
+    /*#__PURE__*/
+    // eslint-disable-next-line jsx-a11y/anchor-has-content
+    React__namespace.createElement(
+      'a',
+      _extends({}, rest, {
+        href: absoluteHref || href,
+        onClick: isExternal || reloadDocument ? onClick : handleClick,
+        ref: ref,
+        target: target
+      })
+    )
+  );
+});
+if (process.env.NODE_ENV !== 'production') {
+  Link.displayName = 'Link';
+}
+/**
+ * A `<Link>` wrapper that knows if it's "active" or not.
+ */
+const NavLink = /*#__PURE__*/ React__namespace.forwardRef(function NavLinkWithRef(_ref8, ref) {
+  let {
+      'aria-current': ariaCurrentProp = 'page',
+      caseSensitive = false,
+      className: classNameProp = '',
+      end = false,
+      style: styleProp,
+      to,
+      viewTransition,
+      children
+    } = _ref8,
+    rest = _objectWithoutPropertiesLoose(_ref8, _excluded2);
+  let path = reactRouter.useResolvedPath(to, {
+    relative: rest.relative
+  });
+  let location = reactRouter.useLocation();
+  let routerState = React__namespace.useContext(reactRouter.UNSAFE_DataRouterStateContext);
+  let { navigator, basename } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext);
+  let isTransitioning =
+    routerState != null &&
+    // Conditional usage is OK here because the usage of a data router is static
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useViewTransitionState(path) &&
+    viewTransition === true;
+  let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;
+  let locationPathname = location.pathname;
+  let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;
+  if (!caseSensitive) {
+    locationPathname = locationPathname.toLowerCase();
+    nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;
+    toPathname = toPathname.toLowerCase();
+  }
+  if (nextLocationPathname && basename) {
+    nextLocationPathname = stripBasename(nextLocationPathname, basename) || nextLocationPathname;
+  }
+  // If the `to` has a trailing slash, look at that exact spot.  Otherwise,
+  // we're looking for a slash _after_ what's in `to`.  For example:
+  //
+  // <NavLink to="/users"> and <NavLink to="/users/">
+  // both want to look for a / at index 6 to match URL `/users/matt`
+  const endSlashPosition = toPathname !== '/' && toPathname.endsWith('/') ? toPathname.length - 1 : toPathname.length;
+  let isActive = locationPathname === toPathname || (!end && locationPathname.startsWith(toPathname) && locationPathname.charAt(endSlashPosition) === '/');
+  let isPending =
+    nextLocationPathname != null &&
+    (nextLocationPathname === toPathname || (!end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === '/'));
+  let renderProps = {
+    isActive,
+    isPending,
+    isTransitioning
+  };
+  let ariaCurrent = isActive ? ariaCurrentProp : undefined;
+  let className;
+  if (typeof classNameProp === 'function') {
+    className = classNameProp(renderProps);
+  } else {
+    // If the className prop is not a function, we use a default `active`
+    // class for <NavLink />s that are active. In v5 `active` was the default
+    // value for `activeClassName`, but we are removing that API and can still
+    // use the old default behavior for a cleaner upgrade path and keep the
+    // simple styling rules working as they currently do.
+    className = [classNameProp, isActive ? 'active' : null, isPending ? 'pending' : null, isTransitioning ? 'transitioning' : null].filter(Boolean).join(' ');
+  }
+  let style = typeof styleProp === 'function' ? styleProp(renderProps) : styleProp;
+  return /*#__PURE__*/ React__namespace.createElement(
+    Link,
+    _extends({}, rest, {
+      'aria-current': ariaCurrent,
+      className: className,
+      ref: ref,
+      style: style,
+      to: to,
+      viewTransition: viewTransition
+    }),
+    typeof children === 'function' ? children(renderProps) : children
+  );
+});
+if (process.env.NODE_ENV !== 'production') {
+  NavLink.displayName = 'NavLink';
+}
+/**
+ * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except
+ * that the interaction with the server is with `fetch` instead of new document
+ * requests, allowing components to add nicer UX to the page as the form is
+ * submitted and returns with data.
+ */
+const Form = /*#__PURE__*/ React__namespace.forwardRef((_ref9, forwardedRef) => {
+  let { fetcherKey, navigate, reloadDocument, replace, state, method = defaultMethod, action, onSubmit, relative, preventScrollReset, viewTransition } = _ref9,
+    props = _objectWithoutPropertiesLoose(_ref9, _excluded3);
+  let submit = useSubmit();
+  let formAction = useFormAction(action, {
+    relative
+  });
+  let formMethod = method.toLowerCase() === 'get' ? 'get' : 'post';
+  let submitHandler = (event) => {
+    onSubmit && onSubmit(event);
+    if (event.defaultPrevented) return;
+    event.preventDefault();
+    let submitter = event.nativeEvent.submitter;
+    let submitMethod = (submitter == null ? void 0 : submitter.getAttribute('formmethod')) || method;
+    submit(submitter || event.currentTarget, {
+      fetcherKey,
+      method: submitMethod,
+      navigate,
+      replace,
+      state,
+      relative,
+      preventScrollReset,
+      viewTransition
+    });
+  };
+  return /*#__PURE__*/ React__namespace.createElement(
+    'form',
+    _extends(
+      {
+        ref: forwardedRef,
+        method: formMethod,
+        action: formAction,
+        onSubmit: reloadDocument ? onSubmit : submitHandler
+      },
+      props
+    )
+  );
+});
+if (process.env.NODE_ENV !== 'production') {
+  Form.displayName = 'Form';
+}
+if (process.env.NODE_ENV !== 'production');
+//#endregion
+////////////////////////////////////////////////////////////////////////////////
+//#region Hooks
+////////////////////////////////////////////////////////////////////////////////
+var DataRouterHook;
+(function (DataRouterHook) {
+  DataRouterHook['UseScrollRestoration'] = 'useScrollRestoration';
+  DataRouterHook['UseSubmit'] = 'useSubmit';
+  DataRouterHook['UseSubmitFetcher'] = 'useSubmitFetcher';
+  DataRouterHook['UseFetcher'] = 'useFetcher';
+  DataRouterHook['useViewTransitionState'] = 'useViewTransitionState';
+})(DataRouterHook || (DataRouterHook = {}));
+var DataRouterStateHook;
+(function (DataRouterStateHook) {
+  DataRouterStateHook['UseFetcher'] = 'useFetcher';
+  DataRouterStateHook['UseFetchers'] = 'useFetchers';
+  DataRouterStateHook['UseScrollRestoration'] = 'useScrollRestoration';
+})(DataRouterStateHook || (DataRouterStateHook = {}));
+// Internal hooks
+function getDataRouterConsoleError(hookName) {
+  return hookName + ' must be used within a data router.  See https://reactrouter.com/v6/routers/picking-a-router.';
+}
+function useDataRouterContext(hookName) {
+  let ctx = React__namespace.useContext(reactRouter.UNSAFE_DataRouterContext);
+  !ctx ? (process.env.NODE_ENV !== 'production' ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false)) : void 0;
+  return ctx;
+}
+// External hooks
+/**
+ * Handles the click behavior for router `<Link>` components. This is useful if
+ * you need to create custom `<Link>` components with the same click behavior we
+ * use in our exported `<Link>`.
+ */
+function useLinkClickHandler(to, _temp) {
+  let { target, replace: replaceProp, state, preventScrollReset, relative, viewTransition } = _temp === void 0 ? {} : _temp;
+  let navigate = reactRouter.useNavigate();
+  let location = reactRouter.useLocation();
+  let path = reactRouter.useResolvedPath(to, {
+    relative
+  });
+  return React__namespace.useCallback(
+    (event) => {
+      if (shouldProcessLinkClick(event, target)) {
+        event.preventDefault();
+        // If the URL hasn't changed, a regular <a> will do a replace instead of
+        // a push, so do the same here unless the replace prop is explicitly set
+        let replace = replaceProp !== undefined ? replaceProp : reactRouter.createPath(location) === reactRouter.createPath(path);
+        navigate(to, {
+          replace,
+          state,
+          preventScrollReset,
+          relative,
+          viewTransition
+        });
+      }
+    },
+    [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, viewTransition]
+  );
+}
+function validateClientSideSubmission() {
+  if (typeof document === 'undefined') {
+    throw new Error('You are calling submit during the server render. ' + 'Try calling submit within a `useEffect` or callback instead.');
+  }
+}
+let fetcherId = 0;
+let getUniqueFetcherId = () => '__' + String(++fetcherId) + '__';
+/**
+ * Returns a function that may be used to programmatically submit a form (or
+ * some arbitrary data) to the server.
+ */
+function useSubmit() {
+  let { router } = useDataRouterContext(DataRouterHook.UseSubmit);
+  let { basename } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext);
+  let currentRouteId = reactRouter.UNSAFE_useRouteId();
+  return React__namespace.useCallback(
+    function (target, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      validateClientSideSubmission();
+      let { action, method, encType, formData, body } = getFormSubmissionInfo(target, basename);
+      if (options.navigate === false) {
+        let key = options.fetcherKey || getUniqueFetcherId();
+        router.fetch(key, currentRouteId, options.action || action, {
+          preventScrollReset: options.preventScrollReset,
+          formData,
+          body,
+          formMethod: options.method || method,
+          formEncType: options.encType || encType,
+          flushSync: options.flushSync
+        });
+      } else {
+        router.navigate(options.action || action, {
+          preventScrollReset: options.preventScrollReset,
+          formData,
+          body,
+          formMethod: options.method || method,
+          formEncType: options.encType || encType,
+          replace: options.replace,
+          state: options.state,
+          fromRouteId: currentRouteId,
+          flushSync: options.flushSync,
+          viewTransition: options.viewTransition
+        });
+      }
+    },
+    [router, basename, currentRouteId]
+  );
+}
+// v7: Eventually we should deprecate this entirely in favor of using the
+// router method directly?
+function useFormAction(action, _temp2) {
+  let { relative } = _temp2 === void 0 ? {} : _temp2;
+  let { basename } = React__namespace.useContext(reactRouter.UNSAFE_NavigationContext);
+  let routeContext = React__namespace.useContext(reactRouter.UNSAFE_RouteContext);
+  !routeContext ? (process.env.NODE_ENV !== 'production' ? invariant(false, 'useFormAction must be used inside a RouteContext') : invariant(false)) : void 0;
+  let [match] = routeContext.matches.slice(-1);
+  // Shallow clone path so we can modify it below, otherwise we modify the
+  // object referenced by useMemo inside useResolvedPath
+  let path = _extends(
+    {},
+    reactRouter.useResolvedPath(action ? action : '.', {
+      relative
+    })
+  );
+  // If no action was specified, browsers will persist current search params
+  // when determining the path, so match that behavior
+  // https://github.com/remix-run/remix/issues/927
+  let location = reactRouter.useLocation();
+  if (action == null) {
+    // Safe to write to this directly here since if action was undefined, we
+    // would have called useResolvedPath(".") which will never include a search
+    path.search = location.search;
+    // When grabbing search params from the URL, remove any included ?index param
+    // since it might not apply to our contextual route.  We add it back based
+    // on match.route.index below
+    let params = new URLSearchParams(path.search);
+    let indexValues = params.getAll('index');
+    let hasNakedIndexParam = indexValues.some((v) => v === '');
+    if (hasNakedIndexParam) {
+      params.delete('index');
+      indexValues.filter((v) => v).forEach((v) => params.append('index', v));
+      let qs = params.toString();
+      path.search = qs ? '?' + qs : '';
+    }
+  }
+  if ((!action || action === '.') && match.route.index) {
+    path.search = path.search ? path.search.replace(/^\?/, '?index&') : '?index';
+  }
+  // If we're operating within a basename, prepend it to the pathname prior
+  // to creating the form action.  If this is a root navigation, then just use
+  // the raw basename which allows the basename to have full control over the
+  // presence of a trailing slash on root actions
+  if (basename !== '/') {
+    path.pathname = path.pathname === '/' ? basename : joinPaths([basename, path.pathname]);
+  }
+  return reactRouter.createPath(path);
+}
+/**
+ * Return a boolean indicating if there is an active view transition to the
+ * given href.  You can use this value to render CSS classes or viewTransitionName
+ * styles onto your elements
+ *
+ * @param href The destination href
+ * @param [opts.relative] Relative routing type ("route" | "path")
+ */
+function useViewTransitionState(to, opts) {
+  if (opts === void 0) {
+    opts = {};
+  }
+  let vtContext = React__namespace.useContext(ViewTransitionContext);
+  !(vtContext != null)
+    ? process.env.NODE_ENV !== 'production'
+      ? invariant(
+          false,
+          "`useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`.  " +
+            'Did you accidentally import `RouterProvider` from `react-router`?'
+        )
+      : invariant(false)
+    : void 0;
+  let { basename } = useDataRouterContext(DataRouterHook.useViewTransitionState);
+  let path = reactRouter.useResolvedPath(to, {
+    relative: opts.relative
+  });
+  if (!vtContext.isTransitioning) {
+    return false;
+  }
+  let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname;
+  let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname;
+  // Transition is active if we're going to or coming from the indicated
+  // destination.  This ensures that other PUSH navigations that reverse
+  // an indicated transition apply.  I.e., on the list view you have:
+  //
+  //   <NavLink to="/details/1" viewTransition>
+  //
+  // If you click the breadcrumb back to the list view:
+  //
+  //   <NavLink to="/list" viewTransition>
+  //
+  // We should apply the transition because it's indicated as active going
+  // from /list -> /details/1 and therefore should be active on the reverse
+  // (even though this isn't strictly a POP reverse)
+  return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;
+}
+
 var CHILD_MAX_AGE = 17;
 var initialState$6 = {
   formValues: undefined
@@ -18145,6 +18969,7 @@ var Message = function (_a) {
 var Confirmation = function () {
   var dispatch = useAppDispatch();
   var settings = React.useContext(SettingsContext);
+  var navigate = reactRouter.useNavigate();
   var bookingNumber = reactRedux.useSelector(selectBookingNumber);
   var bookingQueryString = reactRedux.useSelector(selectBookingQueryString);
   var isOption = reactRedux.useSelector(selectIsOption);
@@ -18152,7 +18977,7 @@ var Confirmation = function () {
     if (settings.skipRouter) {
       dispatch(setCurrentStep(OPTIONS_FORM_STEP));
     } else {
-      router.navigate(''.concat(settings.basePath).concat(settings.error.pathSuffix, '?').concat(bookingQueryString));
+      navigate(''.concat(settings.basePath).concat(settings.error.pathSuffix, '?').concat(bookingQueryString));
     }
   }
   var translations = reactRedux.useSelector(selectTranslations);
@@ -18236,6 +19061,7 @@ var Confirmation = function () {
 
 var Error$1 = function () {
   var dispatch = useAppDispatch();
+  var navigate = reactRouter.useNavigate();
   var settings = React.useContext(SettingsContext);
   var bookingQueryString = reactRedux.useSelector(selectBookingQueryString);
   var tryAgainUrl = ''.concat(settings.basePath, '?').concat(bookingQueryString);
@@ -18247,7 +19073,7 @@ var Error$1 = function () {
       }
     } else {
       dispatch(setIsRetry(true));
-      router.navigate(tryAgainUrl);
+      navigate(tryAgainUrl);
     }
   };
   var translations = reactRedux.useSelector(selectTranslations);
@@ -19865,6 +20691,7 @@ var FlightOptionModal = function (_a) {
 var FlightOptionsForm = function () {
   var _a, _b, _c, _d;
   var settings = React.useContext(SettingsContext);
+  var navigate = reactRouter.useNavigate();
   var translations = reactRedux.useSelector(selectTranslations);
   var dispatch = useAppDispatch();
   var packageDetails = reactRedux.useSelector(selectPackageDetails);
@@ -19883,9 +20710,9 @@ var FlightOptionsForm = function () {
       dispatch(setCurrentStep(ROOM_OPTIONS_FORM_STEP));
     } else {
       if (settings.roomOptions.isHidden) {
-        router.navigate(''.concat(settings.basePath).concat(settings.options.pathSuffix, '?').concat(bookingQueryString));
+        navigate(''.concat(settings.basePath).concat(settings.options.pathSuffix, '?').concat(bookingQueryString));
       } else {
-        router.navigate(''.concat(settings.basePath).concat(settings.roomOptions.pathSuffix, '?').concat(bookingQueryString));
+        navigate(''.concat(settings.basePath).concat(settings.roomOptions.pathSuffix, '?').concat(bookingQueryString));
       }
     }
     e.preventDefault();
@@ -20023,7 +20850,7 @@ var FlightOptionsForm = function () {
             )
           : travelersFirstStep
           ? React__default['default'].createElement(
-              router.Link,
+              Link,
               {
                 to: ''.concat(settings.basePath).concat(settings.travellers.pathSuffix, '?').concat(bookingQueryString),
                 title: translations.STEPS.PREVIOUS,
@@ -21924,6 +22751,7 @@ var PrintOfferButton = function (_a) {
 var OptionsForm = function () {
   var _a, _b;
   var settings = React.useContext(SettingsContext);
+  var navigate = reactRouter.useNavigate();
   var token = settings.token;
   var translations = reactRedux.useSelector(selectTranslations);
   var dispatch = useAppDispatch();
@@ -21999,9 +22827,9 @@ var OptionsForm = function () {
       }
     } else {
       if (travelersFirstStep) {
-        router.navigate(''.concat(settings.basePath).concat(settings.summary.pathSuffix, '?').concat(bookingQueryString));
+        navigate(''.concat(settings.basePath).concat(settings.summary.pathSuffix, '?').concat(bookingQueryString));
       } else {
-        router.navigate(''.concat(settings.basePath).concat(settings.travellers.pathSuffix, '?').concat(bookingQueryString));
+        navigate(''.concat(settings.basePath).concat(settings.travellers.pathSuffix, '?').concat(bookingQueryString));
       }
     }
     e.preventDefault();
@@ -22300,7 +23128,7 @@ var OptionsForm = function () {
                   translations.STEPS.PREVIOUS
                 )
               : React__default['default'].createElement(
-                  router.Link,
+                  Link,
                   { to: previousUrl, title: translations.STEPS.PREVIOUS, className: 'cta cta--secondary' },
                   translations.STEPS.PREVIOUS
                 )
@@ -22531,6 +23359,7 @@ var TravelerRooms = function (_a) {
 
 var RoomOptionsForm = function () {
   var settings = React.useContext(SettingsContext);
+  var navigate = reactRouter.useNavigate();
   var translations = reactRedux.useSelector(selectTranslations);
   var dispatch = useAppDispatch();
   var packageDetails = reactRedux.useSelector(selectPackageDetails);
@@ -22547,7 +23376,7 @@ var RoomOptionsForm = function () {
     if (settings.skipRouter) {
       dispatch(setCurrentStep(OPTIONS_FORM_STEP));
     } else {
-      router.navigate(''.concat(settings.basePath).concat(settings.options.pathSuffix, '?').concat(bookingQueryString));
+      navigate(''.concat(settings.basePath).concat(settings.options.pathSuffix, '?').concat(bookingQueryString));
     }
     e.preventDefault();
   };
@@ -22622,7 +23451,7 @@ var RoomOptionsForm = function () {
                   translations.STEPS.PREVIOUS
                 )
               : React__default['default'].createElement(
-                  router.Link,
+                  Link,
                   {
                     to: ''.concat(settings.basePath).concat(settings.flightOptions.pathSuffix, '?').concat(bookingQueryString),
                     title: translations.STEPS.PREVIOUS,
@@ -23424,6 +24253,7 @@ var SummaryPerBookingOptionGroup = function (_a) {
 var Summary = function () {
   var _a, _b, _c, _d, _e, _f;
   var dispatch = useAppDispatch();
+  var navigate = reactRouter.useNavigate();
   var settings = React.useContext(SettingsContext);
   var _g = React.useState(false),
     isSubmitting = _g[0],
@@ -23463,7 +24293,7 @@ var Summary = function () {
     if (settings.skipRouter) {
       dispatch(setCurrentStep(TRAVELERS_FORM_STEP));
     } else {
-      router.navigate(''.concat(settings.basePath, '?').concat(bookingQueryString));
+      navigate(''.concat(settings.basePath, '?').concat(bookingQueryString));
     }
   }
   var rooms = reactRedux.useSelector(selectRooms);
@@ -23509,8 +24339,11 @@ var Summary = function () {
               return [2 /*return*/];
             }
             if (bookRequest.payload.returnPaymentUrl) {
-              location_1 = router.useLocation();
-              bookRequest.payload.redirectUrl = ''.concat(location_1.protocol, '//').concat(location_1.host).concat(settings.basePath);
+              if (typeof window !== 'undefined') {
+                location_1 = window.location;
+                window.scrollTo(0, 0);
+                bookRequest.payload.redirectUrl = ''.concat(location_1.protocol, '//').concat(location_1.host).concat(settings.basePath);
+              }
             }
             _b.label = 1;
           case 1:
@@ -23531,7 +24364,7 @@ var Summary = function () {
               if (settings.skipRouter) {
                 dispatch(setCurrentStep(CONFIRMATION_STEP));
               } else {
-                router.navigate(''.concat(settings.basePath).concat(settings.confirmation.pathSuffix, '?').concat(bookingQueryString));
+                navigate(''.concat(settings.basePath).concat(settings.confirmation.pathSuffix, '?').concat(bookingQueryString));
               }
             }
             return [3 /*break*/, 5];
@@ -23540,7 +24373,7 @@ var Summary = function () {
             if (settings.skipRouter) {
               dispatch(setCurrentStep(ERROR_STEP));
             } else {
-              router.navigate(''.concat(settings.basePath).concat(settings.error.pathSuffix, '?').concat(bookingQueryString));
+              navigate(''.concat(settings.basePath).concat(settings.error.pathSuffix, '?').concat(bookingQueryString));
             }
             return [3 /*break*/, 5];
           case 4:
@@ -24204,7 +25037,7 @@ var Summary = function () {
                 translations.STEPS.PREVIOUS
               )
             : React__default['default'].createElement(
-                router.Link,
+                Link,
                 {
                   to: ''.concat(settings.basePath).concat(settings.travellers.pathSuffix, '?').concat(bookingQueryString),
                   title: translations.STEPS.PREVIOUS,
@@ -24822,6 +25655,7 @@ function createInitialValues(formRooms, startDate, agentAdressId, personTranslat
 var TravelersForm = function () {
   var _a, _b, _c, _d, _e, _f, _g, _h;
   var dispatch = useAppDispatch();
+  var navigate = reactRouter.useNavigate();
   var settings = React.useContext(SettingsContext);
   var bookingQueryString = reactRedux.useSelector(selectBookingQueryString);
   var startDate = reactRedux.useSelector(selectStartDate);
@@ -24874,7 +25708,7 @@ var TravelersForm = function () {
           if (settings.skipRouter) {
             dispatch(setCurrentStep(SUMMARY_STEP));
           } else {
-            router.navigate(''.concat(settings.basePath).concat(settings.summary.pathSuffix, '?').concat(bookingQueryString));
+            navigate(''.concat(settings.basePath).concat(settings.summary.pathSuffix, '?').concat(bookingQueryString));
           }
         }
       })
@@ -24901,9 +25735,9 @@ var TravelersForm = function () {
             }
           } else {
             if (travelersFirstStep) {
-              router.navigate(''.concat(settings.basePath).concat(settings.flightOptions.pathSuffix, '?').concat(bookingQueryString));
+              navigate(''.concat(settings.basePath).concat(settings.flightOptions.pathSuffix, '?').concat(bookingQueryString));
             } else {
-              router.navigate(''.concat(settings.basePath).concat(settings.summary.pathSuffix, '?').concat(bookingQueryString));
+              navigate(''.concat(settings.basePath).concat(settings.summary.pathSuffix, '?').concat(bookingQueryString));
             }
           }
         }
@@ -24984,7 +25818,7 @@ var TravelersForm = function () {
         query = 'rooms=('.concat(roomsString, ')');
       }
       var newUrl = ''.concat(window.location.pathname, '?').concat(query);
-      router.navigate(newUrl, { replace: true });
+      navigate(newUrl, { replace: true });
     },
     [formik$1.values]
   );
@@ -26004,7 +26838,7 @@ var TravelersForm = function () {
           )
         : !travelersFirstStep
         ? React__default['default'].createElement(
-            router.Link,
+            Link,
             {
               to: ''.concat(settings.basePath).concat(settings.options.pathSuffix, '?').concat(bookingQueryString),
               title: translations.STEPS.PREVIOUS,
@@ -26050,7 +26884,8 @@ var Booking = function (_a) {
     isOffer = _b.isOffer,
     allowOption = _b.allowOption;
   var dispatch = useAppDispatch();
-  var location = router.useLocation();
+  var location = reactRouter.useLocation();
+  var navigate = reactRouter.useNavigate();
   var productAttributes = reactRedux.useSelector(selectProductAttributes);
   var bookingAttributes = reactRedux.useSelector(selectBookingAttributes);
   var rooms = reactRedux.useSelector(selectBookingRooms);
@@ -26103,7 +26938,7 @@ var Booking = function (_a) {
       }
       if (!lodash.isNil(bookingNumber)) {
         dispatch(setBookingNumber(bookingNumber));
-        router.navigate(''.concat(basePath).concat(confirmation.pathSuffix, '?bookingNr=').concat(bookingNumber));
+        navigate(''.concat(basePath).concat(confirmation.pathSuffix, '?bookingNr=').concat(bookingNumber));
       }
       var nextBookingAttrs = {
         startDate: startDate,
@@ -26265,61 +27100,77 @@ var Booking = function (_a) {
             'div',
             { className: 'booking__panel' },
             React__default['default'].createElement(
-              router.Router,
-              { basepath: basePath },
+              reactRouter.Routes,
+              null,
               travelersFirstStep &&
-                React__default['default'].createElement(StepRoute, {
+                React__default['default'].createElement(reactRouter.Route, {
                   path: '/',
-                  number: numberIndex++,
-                  title: translations.STEPS.PERSONAL_DETAILS,
-                  component: React__default['default'].createElement(TravelersForm, null)
+                  element: React__default['default'].createElement(StepRoute, {
+                    number: numberIndex++,
+                    title: translations.STEPS.PERSONAL_DETAILS,
+                    component: React__default['default'].createElement(TravelersForm, null)
+                  })
                 }),
               !flightOptions.isHidden &&
                 flightOptions.pathSuffix &&
-                React__default['default'].createElement(StepRoute, {
+                React__default['default'].createElement(reactRouter.Route, {
                   path: '/',
-                  number: numberIndex++,
-                  title: translations.STEPS.FLIGHT_OPTIONS,
-                  component: React__default['default'].createElement(FlightOptionsForm, null)
+                  element: React__default['default'].createElement(StepRoute, {
+                    number: numberIndex++,
+                    title: translations.STEPS.FLIGHT_OPTIONS,
+                    component: React__default['default'].createElement(FlightOptionsForm, null)
+                  })
                 }),
               !roomOptions.isHidden &&
                 roomOptions.pathSuffix &&
-                React__default['default'].createElement(StepRoute, {
+                React__default['default'].createElement(reactRouter.Route, {
                   path: roomOptions.pathSuffix,
-                  number: numberIndex++,
-                  title: translations.STEPS.ROOM_OPTIONS,
-                  component: React__default['default'].createElement(RoomOptionsForm, null)
+                  element: React__default['default'].createElement(StepRoute, {
+                    number: numberIndex++,
+                    title: translations.STEPS.ROOM_OPTIONS,
+                    component: React__default['default'].createElement(RoomOptionsForm, null)
+                  })
                 }),
-              React__default['default'].createElement(StepRoute, {
+              React__default['default'].createElement(reactRouter.Route, {
                 path: options.pathSuffix,
-                number: numberIndex++,
-                title: translations.STEPS.EXTRA_OPTIONS,
-                component: React__default['default'].createElement(OptionsForm, null)
+                element: React__default['default'].createElement(StepRoute, {
+                  number: numberIndex++,
+                  title: translations.STEPS.EXTRA_OPTIONS,
+                  component: React__default['default'].createElement(OptionsForm, null)
+                })
               }),
               !travelersFirstStep &&
-                React__default['default'].createElement(StepRoute, {
+                React__default['default'].createElement(reactRouter.Route, {
                   path: travellers.pathSuffix,
-                  number: numberIndex++,
-                  title: translations.STEPS.PERSONAL_DETAILS,
-                  component: React__default['default'].createElement(TravelersForm, null)
+                  element: React__default['default'].createElement(StepRoute, {
+                    number: numberIndex++,
+                    title: translations.STEPS.PERSONAL_DETAILS,
+                    component: React__default['default'].createElement(TravelersForm, null)
+                  })
                 }),
-              React__default['default'].createElement(StepRoute, {
+              React__default['default'].createElement(reactRouter.Route, {
                 path: summary.pathSuffix,
-                number: numberIndex++,
-                title: translations.STEPS.SUMMARY,
-                component: React__default['default'].createElement(Summary, null)
+                element: React__default['default'].createElement(StepRoute, {
+                  number: numberIndex++,
+                  title: translations.STEPS.SUMMARY,
+                  component: React__default['default'].createElement(Summary, null)
+                })
               }),
-              React__default['default'].createElement(StepRoute, {
+              React__default['default'].createElement(reactRouter.Route, {
                 path: confirmation.pathSuffix,
-                number: numberIndex++,
-                title: translations.STEPS.CONFIRMATION,
-                component: React__default['default'].createElement(Confirmation, null)
+                element: React__default['default'].createElement(StepRoute, {
+                  number: numberIndex++,
+                  title: translations.STEPS.CONFIRMATION,
+                  component: React__default['default'].createElement(Confirmation, null)
+                })
               }),
-              React__default['default'].createElement(StepRoute, {
+              React__default['default'].createElement(reactRouter.Route, {
                 path: error.pathSuffix,
-                number: numberIndex++,
-                title: translations.STEPS.ERROR,
-                component: React__default['default'].createElement(Error$1, null)
+                element: React__default['default'].createElement(StepRoute, {
+                  number: numberIndex++,
+                  title: translations.STEPS.ERROR,
+                  component: React__default['default'].createElement(Error$1, null)
+                })
               })
             )
           ),
@@ -27833,7 +28684,7 @@ var Navbar = function (_a) {
   var _d = React.useState(),
     activeMobileGroup = _d[0],
     setActiveMobileGroup = _d[1];
-  var location = router.useLocation();
+  var location = reactRouter.useLocation();
   var normalizePath = function (path) {
     return path.replace(/\/+$/, '');
   };