droplinked-chatbot-next 1.0.2 → 1.0.3

package/dist/index.esm.js

@@ -1,8 +1,8 @@
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import * as Chakra from '@chakra-ui/react';
-import { VStack, Text, Box, Input, Button, HStack, Image as Image$1, Spacer, IconButton, Link, Grid, Flex, Tooltip as Tooltip$1, Center, DrawerHeader, useDisclosure, DrawerBody } from '@chakra-ui/react';
-import * as React from 'react';
-import React__default, { useState, useMemo, useRef, useEffect, useCallback } from 'react';
+import { VStack, Text, Box, Input, Button, HStack, Image as Image$1, Spacer, IconButton, Link as Link$1, Grid, Flex, Tooltip as Tooltip$1, Center, DrawerHeader, useDisclosure, DrawerBody } from '@chakra-ui/react';
+import * as React3 from 'react';
+import React3__default, { useState, useMemo, useRef, useEffect, useCallback } from 'react';
 
 function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
@@ -4730,31 +4730,59 @@ var useChatbot = function useChatbot(_ref) {
   };
 };
 
-var _excluded$a = ["color"];
-var SendSm = function SendSm(_ref) {
+var _excluded$b = ["color"];
+var SendMd = function SendMd(_ref) {
   var _ref$color = _ref.color,
     color = _ref$color === void 0 ? "black" : _ref$color,
-    props = _objectWithoutProperties(_ref, _excluded$a);
+    props = _objectWithoutProperties(_ref, _excluded$b);
   return jsxs("svg", _objectSpread2(_objectSpread2({
-    width: "16",
-    height: "16",
-    viewBox: "0 0 16 16",
+    width: "20",
+    height: "20",
+    viewBox: "0 0 20 20",
     fill: "none",
     xmlns: "http://www.w3.org/2000/svg"
   }, props), {}, {
     children: [jsx("path", {
-      d: "M4.29963 2.79051L12.7242 7.00511C12.9077 7.0989 13.0618 7.24144 13.1693 7.41707C13.2769 7.59258 13.3337 7.79437 13.3337 8.00007C13.3337 8.20588 13.2769 8.40756 13.1693 8.58319C13.0618 8.7587 12.9077 8.90124 12.7242 8.99503L4.29963 13.2096C4.08923 13.3176 3.84998 13.3563 3.61616 13.3203C3.38235 13.2842 3.16598 13.1752 2.99807 13.0089C2.83016 12.8426 2.71932 12.6275 2.68144 12.3945C2.64357 12.1614 2.6806 11.9223 2.78723 11.7116L4.40045 8.50314C4.47924 8.34708 4.52029 8.1748 4.52029 8.00007C4.52029 7.82534 4.47924 7.65306 4.40045 7.497L2.78723 4.28854C2.6806 4.07778 2.64357 3.83876 2.68144 3.60571C2.71932 3.37267 2.83016 3.15757 2.99807 2.99125C3.16598 2.82494 3.38235 2.71593 3.61616 2.67986C3.84998 2.64381 4.08923 2.68254 4.29963 2.79051Z",
+      d: "M5.3738 3.48795L15.9045 8.7562C16.1339 8.87345 16.3265 9.05162 16.4609 9.27115C16.5953 9.49055 16.6663 9.74278 16.6663 9.99991C16.6663 10.2572 16.5953 10.5093 16.4609 10.7288C16.3265 10.9482 16.1339 11.1264 15.9045 11.2436L5.3738 16.5119C5.1108 16.6469 4.81174 16.6952 4.51947 16.6502C4.22721 16.6051 3.95674 16.4688 3.74686 16.2609C3.53697 16.0531 3.39842 15.7842 3.35107 15.4929C3.30372 15.2015 3.35002 14.9027 3.48331 14.6393L5.49983 10.6287C5.59832 10.4337 5.64963 10.2183 5.64963 9.99991C5.64963 9.78149 5.59832 9.56615 5.49983 9.37107L3.48331 5.36049C3.35002 5.09705 3.30372 4.79827 3.35107 4.50696C3.39842 4.21565 3.53697 3.94678 3.74686 3.73888C3.95674 3.53099 4.22721 3.39473 4.51947 3.34965C4.81174 3.30458 5.1108 3.35299 5.3738 3.48795Z",
       stroke: color,
+      strokeWidth: "1.5",
       "stroke-miterlimit": "10"
     }), jsx("path", {
-      d: "M4.66699 8H7.33366",
+      d: "M5.83301 10H9.16634",
       stroke: color,
+      strokeWidth: "1.5",
       "stroke-miterlimit": "10",
       strokeLinecap: "round"
     })]
   }));
 };
 
+var _excluded$a = ["color"];
+var LetterMd = function LetterMd(_ref) {
+  var _ref$color = _ref.color,
+    color = _ref$color === void 0 ? "black" : _ref$color,
+    props = _objectWithoutProperties(_ref, _excluded$a);
+  return jsxs("svg", _objectSpread2(_objectSpread2({
+    width: "20",
+    height: "20",
+    viewBox: "0 0 20 20",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg"
+  }, props), {}, {
+    children: [jsx("path", {
+      d: "M5.83301 7.5L9.99967 10.4167L14.1663 7.5",
+      stroke: color,
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }), jsx("path", {
+      d: "M1.66699 14.1667V5.83334C1.66699 4.91286 2.41318 4.16667 3.33366 4.16667H16.667C17.5875 4.16667 18.3337 4.91286 18.3337 5.83334V14.1667C18.3337 15.0872 17.5875 15.8333 16.667 15.8333H3.33366C2.41318 15.8333 1.66699 15.0872 1.66699 14.1667Z",
+      stroke: color,
+      strokeWidth: "1.5"
+    })]
+  }));
+};
+
 function EmailCapture(_ref) {
   var onSubmit = _ref.onSubmit,
     _ref$isSubmitting = _ref.isSubmitting,
@@ -4788,7 +4816,9 @@ function EmailCapture(_ref) {
       border: "1px solid",
       borderColor: "#27272A",
       overflow: "hidden",
-      children: [jsx(Input, {
+      children: [jsx(LetterMd, {
+        color: "#7B7B7B"
+      }), jsx(Input, {
         value: email,
         onChange: function onChange(e) {
           return setEmail(e.target.value);
@@ -4834,8 +4864,8 @@ function EmailCapture(_ref) {
           color: "#525252",
           cursor: "not-allowed"
         },
-        px: 2,
-        py: 1,
+        px: 3,
+        py: 2,
         borderRadius: "md",
         height: "auto",
         minHeight: "auto",
@@ -4877,6 +4907,8 @@ function SuggestionChips(_ref) {
         fontSize: "sm",
         fontWeight: "normal",
         lineHeight: "tight",
+        _hover: "none",
+        _active: "none",
         children: s.text
       }, s.id);
     })
@@ -4954,7 +4986,7 @@ function MessageInput(_ref) {
               onKeyDown: function onKeyDown(e) {
                 return e.key === "Enter" && handleSend();
               },
-              placeholder: "  Send a message",
+              placeholder: "Send a message",
               bg: "transparent",
               color: "white",
               border: "none",
@@ -4976,7 +5008,6 @@ function MessageInput(_ref) {
               fontSize: "sm"
             })
           }), jsxs(HStack, {
-            p: 2,
             align: "center",
             w: "full",
             children: [user.logoUrl && jsx(HStack, {
@@ -4994,7 +5025,7 @@ function MessageInput(_ref) {
               onClick: handleSend,
               isDisabled: !input.trim() || isLoading,
               isLoading: isLoading,
-              size: "sm",
+              size: "md",
               bg: !input.trim() || isLoading ? "#262626" : "#2BCFA1",
               _hover: {
                 bg: !input.trim() || isLoading ? "#262626" : "#22B890"
@@ -5005,7 +5036,7 @@ function MessageInput(_ref) {
               },
               borderRadius: "lg",
               border: "none",
-              children: jsx(SendSm, {
+              children: jsx(SendMd, {
                 color: !input.trim() || isLoading ? "#525252" : "white"
               })
             })]
@@ -5023,14 +5054,10 @@ if (typeof document !== "undefined" && !document.getElementById("typing-indicato
   styleElement.textContent = typingIndicatorStyles;
   document.head.appendChild(styleElement);
 }
-var TypingIndicator = /*#__PURE__*/React__default.memo(function TypingIndicator(_ref) {
-  var isVisible = _ref.isVisible,
-    _ref$size = _ref.size,
-    size = _ref$size === void 0 ? "normal" : _ref$size,
-    _ref$state = _ref.state,
-    state = _ref$state === void 0 ? "typing" : _ref$state;
-  var getDotStyle = React__default.useMemo(function () {
-    return function (index, delay, small) {
+var TypingIndicator = /*#__PURE__*/React3__default.memo(function TypingIndicator(_ref) {
+  var isVisible = _ref.isVisible;
+  var getDotStyle = React3__default.useMemo(function () {
+    return function (index, delay) {
       var animationDelay = "".concat(index * 0.2 + delay * 0.5, "s");
       return {
         animation: "typingDotBounce 1.6s ease-in-out infinite",
@@ -5043,11 +5070,11 @@ var TypingIndicator = /*#__PURE__*/React__default.memo(function TypingIndicator(
     animation: isVisible ? 'scaleIn 0.5s ease-out forwards' : 'scaleOut 0.5s ease-in forwards',
     transformOrigin: 'bottom left'
   };
-  var _React$useState = React__default.useState(isVisible),
+  var _React$useState = React3__default.useState(isVisible),
     _React$useState2 = _slicedToArray(_React$useState, 2),
     shouldRender = _React$useState2[0],
     setShouldRender = _React$useState2[1];
-  React__default.useEffect(function () {
+  React3__default.useEffect(function () {
     var timer = null;
     if (isVisible) {
       setShouldRender(true);
@@ -5063,85 +5090,40 @@ var TypingIndicator = /*#__PURE__*/React__default.memo(function TypingIndicator(
     };
   }, [isVisible]);
   if (!shouldRender) return null;
-  var isSmall = size === "small";
-  var dotSize = isSmall ? "6px" : "8px";
-  var smallDotSize = isSmall ? "5px" : "6px";
-  var containerPadding = isSmall ? "8px 12px" : "12px 16px";
-  var smallContainerPadding = isSmall ? "6px 10px" : "8px 12px";
-  var isCompleted = state === "completed";
-  var TypingDots = React__default.useMemo(function () {
-    return /*#__PURE__*/React__default.memo(function (_ref2) {
+  var TypingDots = React3__default.useMemo(function () {
+    return /*#__PURE__*/React3__default.memo(function (_ref2) {
       var _ref2$delay = _ref2.delay,
-        delay = _ref2$delay === void 0 ? 0 : _ref2$delay,
-        _ref2$small = _ref2.small,
-        small = _ref2$small === void 0 ? false : _ref2$small;
+        delay = _ref2$delay === void 0 ? 0 : _ref2$delay;
       return jsx(HStack, {
-        gap: small ? "4px" : "6px",
+        gap: "4px",
         justify: "center",
         children: [0, 1, 2].map(function (index) {
           return jsx(Box, {
-            w: small ? smallDotSize : dotSize,
-            h: small ? smallDotSize : dotSize,
+            boxSize: "8px",
             bg: "#2BCFA1",
             borderRadius: "full",
-            style: getDotStyle(index, delay, small)
+            style: getDotStyle(index, delay)
           }, index);
         })
       });
     });
-  }, [getDotStyle, dotSize, smallDotSize]);
-  if (isCompleted) {
-    return jsx(Box, {
-      alignSelf: "flex-start",
-      maxW: "80%",
-      mb: isSmall ? 2 : 4,
-      style: containerAnimationStyle,
-      children: jsx(Box, {
-        bg: "rgba(43, 207, 161, 0.15)",
-        p: smallContainerPadding,
-        borderRadius: "16px",
-        w: "fit-content",
-        border: "1px solid rgba(43, 207, 161, 0.2)",
-        backdropFilter: "blur(10px)",
-        boxShadow: "0 4px 12px rgba(0, 0, 0, 0.1)",
-        children: jsx(TypingDots, {
-          delay: 0.1,
-          small: true
-        })
-      })
-    });
-  }
+  }, [getDotStyle]);
   return jsx(Box, {
     alignSelf: "flex-start",
     maxW: "80%",
-    mb: isSmall ? 2 : 4,
+    mb: 2,
     style: containerAnimationStyle,
-    children: jsxs(Box, {
-      display: "flex",
-      flexDirection: "column",
-      gap: 2,
-      children: [jsx(Box, {
-        bg: "rgba(34, 197, 94, 0.2)",
-        p: containerPadding,
-        borderRadius: "20px",
-        w: "fit-content",
-        border: "1px solid rgba(34, 197, 94, 0.3)",
-        backdropFilter: "blur(10px)",
-        boxShadow: "0 4px 12px rgba(0, 0, 0, 0.1)",
-        children: jsx(TypingDots, {})
-      }), jsx(Box, {
-        bg: "rgba(34, 197, 94, 0.2)",
-        p: smallContainerPadding,
-        borderRadius: "16px",
-        w: "fit-content",
-        border: "1px solid rgba(34, 197, 94, 0.3)",
-        backdropFilter: "blur(10px)",
-        boxShadow: "0 4px 12px rgba(0, 0, 0, 0.1)",
-        children: jsx(TypingDots, {
-          delay: 0.1,
-          small: true
-        })
-      })]
+    children: jsx(Box, {
+      bg: "rgba(34, 197, 94, 0.2)",
+      p: "10px 14px",
+      borderRadius: "16px",
+      w: "fit-content",
+      border: "1px solid rgba(34, 197, 94, 0.3)",
+      backdropFilter: "blur(10px)",
+      boxShadow: "0 4px 12px rgba(0, 0, 0, 0.1)",
+      children: jsx(TypingDots, {
+        delay: 0.1
+      })
     })
   });
 });
@@ -41386,7 +41368,7 @@ function MarkdownRenderer(_ref) {
         a: function a(_ref3) {
           var href = _ref3.href,
             children = _ref3.children;
-          return jsx(Link, {
+          return jsx(Link$1, {
             href: href,
             color: "#179EF8",
             textDecoration: "underline",
@@ -41625,38 +41607,36 @@ function GradualMessageDisplay(_ref) {
       flexDirection: "column",
       gap: 2,
       children: [(phase === "typing" || phase === "revealing") && jsx(TypingIndicator, {
-        isVisible: true,
-        size: "normal",
-        state: phase === "typing" ? "typing" : "completed"
+        isVisible: true
       }), (phase === "revealing" || phase === "complete") && jsx(Box, {
         position: "relative",
         borderRadius: "12px",
         _before: {
           content: '""',
-          position: 'absolute',
+          position: "absolute",
           zIndex: -1,
-          width: 'calc(100% + 1px)',
-          height: 'calc(100% + 1px)',
+          width: "calc(100% + 1px)",
+          height: "calc(100% + 1px)",
           top: 0,
           left: 0,
-          borderRadius: '12px',
-          backgroundSize: '400% 400%',
+          borderRadius: "12px",
+          backgroundSize: "400% 400%",
           opacity: phase === "revealing" ? 1 : 0,
-          transition: 'opacity 0.3s ease'
+          transition: "opacity 0.3s ease"
         },
         _after: {
           content: '""',
-          position: 'absolute',
+          position: "absolute",
           zIndex: -1,
-          width: 'calc(100% + 1px)',
-          height: 'calc(100% + 1px)',
+          width: "calc(100% + 1px)",
+          height: "calc(100% + 1px)",
           top: 0,
           left: 0,
-          borderRadius: '12px',
-          backgroundSize: '400% 400%',
+          borderRadius: "12px",
+          backgroundSize: "400% 400%",
           opacity: phase === "revealing" ? 1 : 0,
-          transition: 'opacity 0.3s ease',
-          filter: 'blur(100px)'
+          transition: "opacity 0.3s ease",
+          filter: "blur(100px)"
         },
         children: jsx(Box, {
           borderRadius: "11px",
@@ -58963,7 +58943,7 @@ function requireIndex_umd () {
 	hasRequiredIndex_umd = 1;
 	(function (module, exports) {
 		(function (global, factory) {
-		  factory(exports, /*@__PURE__*/ requireLottie(), React__default) ;
+		  factory(exports, /*@__PURE__*/ requireLottie(), React3__default) ;
 		})(index_umd, (function (exports, lottie, React) {
 		  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -65762,8 +65742,7 @@ function MessageList(_ref) {
             clearProcessingMessageId: clearProcessingMessageId
           }, message.id);
         }), isTyping && !currentlyDisplayingMessage && jsx(TypingIndicator, {
-          isVisible: true,
-          size: "normal"
+          isVisible: true
         })]
       })
     })
@@ -65814,6 +65793,1735 @@ function ChatPage(_ref) {
   });
 }
 
+/**
+ * react-router v7.8.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
+ */
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    throw new Error(message);
+  }
+}
+function warning(cond, message) {
+  if (!cond) {
+    if (typeof console !== "undefined") console.warn(message);
+    try {
+      throw new Error(message);
+    } catch (e) {
+    }
+  }
+}
+function createPath({
+  pathname = "/",
+  search = "",
+  hash = ""
+}) {
+  if (search && search !== "?")
+    pathname += search.charAt(0) === "?" ? search : "?" + search;
+  if (hash && hash !== "#")
+    pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+  return pathname;
+}
+function parsePath(path) {
+  let parsedPath = {};
+  if (path) {
+    let hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substring(hashIndex);
+      path = path.substring(0, hashIndex);
+    }
+    let searchIndex = path.indexOf("?");
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substring(searchIndex);
+      path = path.substring(0, searchIndex);
+    }
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+  return parsedPath;
+}
+function matchRoutes(routes, locationArg, basename = "/") {
+  return matchRoutesImpl(routes, locationArg, basename, false);
+}
+function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
+  let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
+  let pathname = stripBasename(location.pathname || "/", basename);
+  if (pathname == null) {
+    return null;
+  }
+  let branches = flattenRoutes(routes);
+  rankRouteBranches(branches);
+  let matches = null;
+  for (let i = 0; matches == null && i < branches.length; ++i) {
+    let decoded = decodePath(pathname);
+    matches = matchRouteBranch(
+      branches[i],
+      decoded,
+      allowPartial
+    );
+  }
+  return matches;
+}
+function flattenRoutes(routes, branches = [], parentsMeta = [], parentPath = "", _hasParentOptionalSegments = false) {
+  let flattenRoute = (route, index, hasParentOptionalSegments = _hasParentOptionalSegments, relativePath) => {
+    let meta = {
+      relativePath: relativePath === void 0 ? route.path || "" : relativePath,
+      caseSensitive: route.caseSensitive === true,
+      childrenIndex: index,
+      route
+    };
+    if (meta.relativePath.startsWith("/")) {
+      if (!meta.relativePath.startsWith(parentPath) && hasParentOptionalSegments) {
+        return;
+      }
+      invariant(
+        meta.relativePath.startsWith(parentPath),
+        `Absolute route path "${meta.relativePath}" nested under path "${parentPath}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`
+      );
+      meta.relativePath = meta.relativePath.slice(parentPath.length);
+    }
+    let path = joinPaths([parentPath, meta.relativePath]);
+    let routesMeta = parentsMeta.concat(meta);
+    if (route.children && route.children.length > 0) {
+      invariant(
+        // Our types know better, but runtime JS may not!
+        // @ts-expect-error
+        route.index !== true,
+        `Index routes must not have child routes. Please remove all child routes from route path "${path}".`
+      );
+      flattenRoutes(
+        route.children,
+        branches,
+        routesMeta,
+        path,
+        hasParentOptionalSegments
+      );
+    }
+    if (route.path == null && !route.index) {
+      return;
+    }
+    branches.push({
+      path,
+      score: computeScore(path, route.index),
+      routesMeta
+    });
+  };
+  routes.forEach((route, index) => {
+    if (route.path === "" || !route.path?.includes("?")) {
+      flattenRoute(route, index);
+    } else {
+      for (let exploded of explodeOptionalSegments(route.path)) {
+        flattenRoute(route, index, true, exploded);
+      }
+    }
+  });
+  return branches;
+}
+function explodeOptionalSegments(path) {
+  let segments = path.split("/");
+  if (segments.length === 0) return [];
+  let [first, ...rest] = segments;
+  let isOptional = first.endsWith("?");
+  let required = first.replace(/\?$/, "");
+  if (rest.length === 0) {
+    return isOptional ? [required, ""] : [required];
+  }
+  let restExploded = explodeOptionalSegments(rest.join("/"));
+  let result = [];
+  result.push(
+    ...restExploded.map(
+      (subpath) => subpath === "" ? required : [required, subpath].join("/")
+    )
+  );
+  if (isOptional) {
+    result.push(...restExploded);
+  }
+  return result.map(
+    (exploded) => path.startsWith("/") && exploded === "" ? "/" : exploded
+  );
+}
+function rankRouteBranches(branches) {
+  branches.sort(
+    (a, b) => a.score !== b.score ? b.score - a.score : compareIndexes(
+      a.routesMeta.map((meta) => meta.childrenIndex),
+      b.routesMeta.map((meta) => meta.childrenIndex)
+    )
+  );
+}
+var paramRe = /^:[\w-]+$/;
+var dynamicSegmentValue = 3;
+var indexRouteValue = 2;
+var emptySegmentValue = 1;
+var staticSegmentValue = 10;
+var splatPenalty = -2;
+var isSplat = (s) => s === "*";
+function computeScore(path, index) {
+  let segments = path.split("/");
+  let initialScore = segments.length;
+  if (segments.some(isSplat)) {
+    initialScore += splatPenalty;
+  }
+  if (index) {
+    initialScore += indexRouteValue;
+  }
+  return segments.filter((s) => !isSplat(s)).reduce(
+    (score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue),
+    initialScore
+  );
+}
+function compareIndexes(a, b) {
+  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
+  return siblings ? (
+    // If two routes are siblings, we should try to match the earlier sibling
+    // first. This allows people to have fine-grained control over the matching
+    // behavior by simply putting routes with identical paths in the order they
+    // want them tried.
+    a[a.length - 1] - b[b.length - 1]
+  ) : (
+    // Otherwise, it doesn't really make sense to rank non-siblings by index,
+    // so they sort equally.
+    0
+  );
+}
+function matchRouteBranch(branch, pathname, allowPartial = false) {
+  let { routesMeta } = branch;
+  let matchedParams = {};
+  let matchedPathname = "/";
+  let matches = [];
+  for (let i = 0; i < routesMeta.length; ++i) {
+    let meta = routesMeta[i];
+    let end = i === routesMeta.length - 1;
+    let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
+    let match = matchPath(
+      { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },
+      remainingPathname
+    );
+    let route = meta.route;
+    if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {
+      match = matchPath(
+        {
+          path: meta.relativePath,
+          caseSensitive: meta.caseSensitive,
+          end: false
+        },
+        remainingPathname
+      );
+    }
+    if (!match) {
+      return null;
+    }
+    Object.assign(matchedParams, match.params);
+    matches.push({
+      // TODO: Can this as be avoided?
+      params: matchedParams,
+      pathname: joinPaths([matchedPathname, match.pathname]),
+      pathnameBase: normalizePathname(
+        joinPaths([matchedPathname, match.pathnameBase])
+      ),
+      route
+    });
+    if (match.pathnameBase !== "/") {
+      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
+    }
+  }
+  return matches;
+}
+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(
+    (memo2, { paramName, isOptional }, index) => {
+      if (paramName === "*") {
+        let splatValue = captureGroups[index] || "";
+        pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+      }
+      const value = captureGroups[index];
+      if (isOptional && !value) {
+        memo2[paramName] = void 0;
+      } else {
+        memo2[paramName] = (value || "").replace(/%2F/g, "/");
+      }
+      return memo2;
+    },
+    {}
+  );
+  return {
+    params,
+    pathname: matchedPathname,
+    pathnameBase,
+    pattern
+  };
+}
+function compilePath(path, caseSensitive = false, 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(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(
+    /\/:([\w-]+)(\?)?/g,
+    (_, paramName, isOptional) => {
+      params.push({ paramName, isOptional: isOptional != null });
+      return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+    }
+  ).replace(/\/([\w-]+)\?(\/|$)/g, "(/$1)?$2");
+  if (path.endsWith("*")) {
+    params.push({ paramName: "*" });
+    regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
+  } else if (end) {
+    regexpSource += "\\/*$";
+  } else if (path !== "" && path !== "/") {
+    regexpSource += "(?:(?=\\/|$))";
+  } else ;
+  let matcher = new RegExp(regexpSource, caseSensitive ? void 0 : "i");
+  return [matcher, params];
+}
+function decodePath(value) {
+  try {
+    return value.split("/").map((v) => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
+  } catch (error) {
+    warning(
+      false,
+      `The URL path "${value}" could not be decoded because it is a malformed URL segment. This is probably due to a bad percent encoding (${error}).`
+    );
+    return value;
+  }
+}
+function stripBasename(pathname, basename) {
+  if (basename === "/") return pathname;
+  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
+    return null;
+  }
+  let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
+  let nextChar = pathname.charAt(startIndex);
+  if (nextChar && nextChar !== "/") {
+    return null;
+  }
+  return pathname.slice(startIndex) || "/";
+}
+function resolvePath(to, fromPathname = "/") {
+  let {
+    pathname: toPathname,
+    search = "",
+    hash = ""
+  } = typeof to === "string" ? parsePath(to) : to;
+  let pathname = toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;
+  return {
+    pathname,
+    search: normalizeSearch(search),
+    hash: normalizeHash(hash)
+  };
+}
+function resolvePathname(relativePath, fromPathname) {
+  let segments = fromPathname.replace(/\/+$/, "").split("/");
+  let relativeSegments = relativePath.split("/");
+  relativeSegments.forEach((segment) => {
+    if (segment === "..") {
+      if (segments.length > 1) segments.pop();
+    } else if (segment !== ".") {
+      segments.push(segment);
+    }
+  });
+  return segments.length > 1 ? segments.join("/") : "/";
+}
+function getInvalidPathError(char, field, dest, path) {
+  return `Cannot include a '${char}' character in a manually specified \`to.${field}\` field [${JSON.stringify(
+    path
+  )}].  Please separate it out to the \`to.${dest}\` field. Alternatively you may provide the full path as a string in <Link to="..."> and the router will parse it for you.`;
+}
+function getPathContributingMatches(matches) {
+  return matches.filter(
+    (match, index) => index === 0 || match.route.path && match.route.path.length > 0
+  );
+}
+function getResolveToMatches(matches) {
+  let pathMatches = getPathContributingMatches(matches);
+  return pathMatches.map(
+    (match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase
+  );
+}
+function resolveTo(toArg, routePathnames, locationPathname, isPathRelative = false) {
+  let to;
+  if (typeof toArg === "string") {
+    to = parsePath(toArg);
+  } else {
+    to = { ...toArg };
+    invariant(
+      !to.pathname || !to.pathname.includes("?"),
+      getInvalidPathError("?", "pathname", "search", to)
+    );
+    invariant(
+      !to.pathname || !to.pathname.includes("#"),
+      getInvalidPathError("#", "pathname", "hash", to)
+    );
+    invariant(
+      !to.search || !to.search.includes("#"),
+      getInvalidPathError("#", "search", "hash", to)
+    );
+  }
+  let isEmptyPath = toArg === "" || to.pathname === "";
+  let toPathname = isEmptyPath ? "/" : to.pathname;
+  let from;
+  if (toPathname == null) {
+    from = locationPathname;
+  } else {
+    let routePathnameIndex = routePathnames.length - 1;
+    if (!isPathRelative && toPathname.startsWith("..")) {
+      let toSegments = toPathname.split("/");
+      while (toSegments[0] === "..") {
+        toSegments.shift();
+        routePathnameIndex -= 1;
+      }
+      to.pathname = toSegments.join("/");
+    }
+    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+  }
+  let path = resolvePath(to, from);
+  let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
+  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+  if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
+    path.pathname += "/";
+  }
+  return path;
+}
+var joinPaths = (paths) => paths.join("/").replace(/\/\/+/g, "/");
+var normalizePathname = (pathname) => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
+var normalizeSearch = (search) => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+var normalizeHash = (hash) => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
+function isRouteErrorResponse(error) {
+  return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
+}
+
+// lib/router/router.ts
+var validMutationMethodsArr = [
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE"
+];
+new Set(
+  validMutationMethodsArr
+);
+var validRequestMethodsArr = [
+  "GET",
+  ...validMutationMethodsArr
+];
+new Set(validRequestMethodsArr);
+var DataRouterContext = React3.createContext(null);
+DataRouterContext.displayName = "DataRouter";
+var DataRouterStateContext = React3.createContext(null);
+DataRouterStateContext.displayName = "DataRouterState";
+React3.createContext(false);
+var ViewTransitionContext = React3.createContext({
+  isTransitioning: false
+});
+ViewTransitionContext.displayName = "ViewTransition";
+var FetchersContext = React3.createContext(
+  /* @__PURE__ */ new Map()
+);
+FetchersContext.displayName = "Fetchers";
+var AwaitContext = React3.createContext(null);
+AwaitContext.displayName = "Await";
+var NavigationContext = React3.createContext(
+  null
+);
+NavigationContext.displayName = "Navigation";
+var LocationContext = React3.createContext(
+  null
+);
+LocationContext.displayName = "Location";
+var RouteContext = React3.createContext({
+  outlet: null,
+  matches: [],
+  isDataRoute: false
+});
+RouteContext.displayName = "Route";
+var RouteErrorContext = React3.createContext(null);
+RouteErrorContext.displayName = "RouteError";
+function useHref(to, { relative } = {}) {
+  invariant(
+    useInRouterContext(),
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    `useHref() may be used only in the context of a <Router> component.`
+  );
+  let { basename, navigator } = React3.useContext(NavigationContext);
+  let { hash, pathname, search } = useResolvedPath(to, { relative });
+  let joinedPathname = pathname;
+  if (basename !== "/") {
+    joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
+  }
+  return navigator.createHref({ pathname: joinedPathname, search, hash });
+}
+function useInRouterContext() {
+  return React3.useContext(LocationContext) != null;
+}
+function useLocation() {
+  invariant(
+    useInRouterContext(),
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    `useLocation() may be used only in the context of a <Router> component.`
+  );
+  return React3.useContext(LocationContext).location;
+}
+var navigateEffectWarning = `You should call navigate() in a React.useEffect(), not when your component is first rendered.`;
+function useIsomorphicLayoutEffect(cb) {
+  let isStatic = React3.useContext(NavigationContext).static;
+  if (!isStatic) {
+    React3.useLayoutEffect(cb);
+  }
+}
+function useNavigate() {
+  let { isDataRoute } = React3.useContext(RouteContext);
+  return isDataRoute ? useNavigateStable() : useNavigateUnstable();
+}
+function useNavigateUnstable() {
+  invariant(
+    useInRouterContext(),
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    `useNavigate() may be used only in the context of a <Router> component.`
+  );
+  let dataRouterContext = React3.useContext(DataRouterContext);
+  let { basename, navigator } = React3.useContext(NavigationContext);
+  let { matches } = React3.useContext(RouteContext);
+  let { pathname: locationPathname } = useLocation();
+  let routePathnamesJson = JSON.stringify(getResolveToMatches(matches));
+  let activeRef = React3.useRef(false);
+  useIsomorphicLayoutEffect(() => {
+    activeRef.current = true;
+  });
+  let navigate = React3.useCallback(
+    (to, options = {}) => {
+      warning(activeRef.current, navigateEffectWarning);
+      if (!activeRef.current) return;
+      if (typeof to === "number") {
+        navigator.go(to);
+        return;
+      }
+      let path = resolveTo(
+        to,
+        JSON.parse(routePathnamesJson),
+        locationPathname,
+        options.relative === "path"
+      );
+      if (dataRouterContext == null && basename !== "/") {
+        path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+      }
+      (!!options.replace ? navigator.replace : navigator.push)(
+        path,
+        options.state,
+        options
+      );
+    },
+    [
+      basename,
+      navigator,
+      routePathnamesJson,
+      locationPathname,
+      dataRouterContext
+    ]
+  );
+  return navigate;
+}
+React3.createContext(null);
+function useResolvedPath(to, { relative } = {}) {
+  let { matches } = React3.useContext(RouteContext);
+  let { pathname: locationPathname } = useLocation();
+  let routePathnamesJson = JSON.stringify(getResolveToMatches(matches));
+  return React3.useMemo(
+    () => resolveTo(
+      to,
+      JSON.parse(routePathnamesJson),
+      locationPathname,
+      relative === "path"
+    ),
+    [to, routePathnamesJson, locationPathname, relative]
+  );
+}
+function useRoutesImpl(routes, locationArg, dataRouterState, unstable_onError, future) {
+  invariant(
+    useInRouterContext(),
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    `useRoutes() may be used only in the context of a <Router> component.`
+  );
+  let { navigator } = React3.useContext(NavigationContext);
+  let { matches: parentMatches } = React3.useContext(RouteContext);
+  let routeMatch = parentMatches[parentMatches.length - 1];
+  let parentParams = routeMatch ? routeMatch.params : {};
+  let parentPathname = routeMatch ? routeMatch.pathname : "/";
+  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : "/";
+  let parentRoute = routeMatch && routeMatch.route;
+  {
+    let parentPath = parentRoute && parentRoute.path || "";
+    warningOnce(
+      parentPathname,
+      !parentRoute || parentPath.endsWith("*") || parentPath.endsWith("*?"),
+      `You rendered descendant <Routes> (or called \`useRoutes()\`) at "${parentPathname}" (under <Route path="${parentPath}">) but the parent route path has no trailing "*". This means if you navigate deeper, the parent won't match anymore and therefore the child routes will never render.
+
+Please change the parent <Route path="${parentPath}"> to <Route path="${parentPath === "/" ? "*" : `${parentPath}/*`}">.`
+    );
+  }
+  let locationFromContext = useLocation();
+  let location;
+  {
+    location = locationFromContext;
+  }
+  let pathname = location.pathname || "/";
+  let remainingPathname = pathname;
+  if (parentPathnameBase !== "/") {
+    let parentSegments = parentPathnameBase.replace(/^\//, "").split("/");
+    let segments = pathname.replace(/^\//, "").split("/");
+    remainingPathname = "/" + segments.slice(parentSegments.length).join("/");
+  }
+  let matches = matchRoutes(routes, { pathname: remainingPathname });
+  {
+    warning(
+      parentRoute || matches != null,
+      `No routes matched location "${location.pathname}${location.search}${location.hash}" `
+    );
+    warning(
+      matches == null || matches[matches.length - 1].route.element !== void 0 || matches[matches.length - 1].route.Component !== void 0 || matches[matches.length - 1].route.lazy !== void 0,
+      `Matched leaf route at location "${location.pathname}${location.search}${location.hash}" does not have an element or Component. This means it will render an <Outlet /> with a null value by default resulting in an "empty" page.`
+    );
+  }
+  let renderedMatches = _renderMatches(
+    matches && matches.map(
+      (match) => Object.assign({}, match, {
+        params: Object.assign({}, parentParams, match.params),
+        pathname: joinPaths([
+          parentPathnameBase,
+          // Re-encode pathnames that were decoded inside matchRoutes
+          navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname
+        ]),
+        pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([
+          parentPathnameBase,
+          // Re-encode pathnames that were decoded inside matchRoutes
+          navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : match.pathnameBase
+        ])
+      })
+    ),
+    parentMatches,
+    dataRouterState,
+    unstable_onError,
+    future
+  );
+  return renderedMatches;
+}
+function DefaultErrorComponent() {
+  let error = useRouteError();
+  let message = isRouteErrorResponse(error) ? `${error.status} ${error.statusText}` : error instanceof Error ? error.message : JSON.stringify(error);
+  let stack = error instanceof Error ? error.stack : null;
+  let lightgrey = "rgba(200,200,200, 0.5)";
+  let preStyles = { padding: "0.5rem", backgroundColor: lightgrey };
+  let codeStyles = { padding: "2px 4px", backgroundColor: lightgrey };
+  let devInfo = null;
+  {
+    console.error(
+      "Error handled by React Router default ErrorBoundary:",
+      error
+    );
+    devInfo = /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement("p", null, "\u{1F4BF} Hey developer \u{1F44B}"), /* @__PURE__ */ React3.createElement("p", null, "You can provide a way better UX than this when your app throws errors by providing your own ", /* @__PURE__ */ React3.createElement("code", { style: codeStyles }, "ErrorBoundary"), " or", " ", /* @__PURE__ */ React3.createElement("code", { style: codeStyles }, "errorElement"), " prop on your route."));
+  }
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement("h2", null, "Unexpected Application Error!"), /* @__PURE__ */ React3.createElement("h3", { style: { fontStyle: "italic" } }, message), stack ? /* @__PURE__ */ React3.createElement("pre", { style: preStyles }, stack) : null, devInfo);
+}
+var defaultErrorElement = /* @__PURE__ */ React3.createElement(DefaultErrorComponent, null);
+var RenderErrorBoundary = class extends React3.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      location: props.location,
+      revalidation: props.revalidation,
+      error: props.error
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  static getDerivedStateFromProps(props, state) {
+    if (state.location !== props.location || state.revalidation !== "idle" && props.revalidation === "idle") {
+      return {
+        error: props.error,
+        location: props.location,
+        revalidation: props.revalidation
+      };
+    }
+    return {
+      error: props.error !== void 0 ? props.error : state.error,
+      location: state.location,
+      revalidation: props.revalidation || state.revalidation
+    };
+  }
+  componentDidCatch(error, errorInfo) {
+    if (this.props.unstable_onError) {
+      this.props.unstable_onError(error, errorInfo);
+    } else {
+      console.error(
+        "React Router caught the following error during render",
+        error
+      );
+    }
+  }
+  render() {
+    return this.state.error !== void 0 ? /* @__PURE__ */ React3.createElement(RouteContext.Provider, { value: this.props.routeContext }, /* @__PURE__ */ React3.createElement(
+      RouteErrorContext.Provider,
+      {
+        value: this.state.error,
+        children: this.props.component
+      }
+    )) : this.props.children;
+  }
+};
+function RenderedRoute({ routeContext, match, children }) {
+  let dataRouterContext = React3.useContext(DataRouterContext);
+  if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {
+    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;
+  }
+  return /* @__PURE__ */ React3.createElement(RouteContext.Provider, { value: routeContext }, children);
+}
+function _renderMatches(matches, parentMatches = [], dataRouterState = null, unstable_onError = null, future = null) {
+  if (matches == null) {
+    if (!dataRouterState) {
+      return null;
+    }
+    if (dataRouterState.errors) {
+      matches = dataRouterState.matches;
+    } else if (parentMatches.length === 0 && !dataRouterState.initialized && dataRouterState.matches.length > 0) {
+      matches = dataRouterState.matches;
+    } else {
+      return null;
+    }
+  }
+  let renderedMatches = matches;
+  let errors = dataRouterState?.errors;
+  if (errors != null) {
+    let errorIndex = renderedMatches.findIndex(
+      (m) => m.route.id && errors?.[m.route.id] !== void 0
+    );
+    invariant(
+      errorIndex >= 0,
+      `Could not find a matching route for errors on route IDs: ${Object.keys(
+        errors
+      ).join(",")}`
+    );
+    renderedMatches = renderedMatches.slice(
+      0,
+      Math.min(renderedMatches.length, errorIndex + 1)
+    );
+  }
+  let renderFallback = false;
+  let fallbackIndex = -1;
+  if (dataRouterState) {
+    for (let i = 0; i < renderedMatches.length; i++) {
+      let match = renderedMatches[i];
+      if (match.route.HydrateFallback || match.route.hydrateFallbackElement) {
+        fallbackIndex = i;
+      }
+      if (match.route.id) {
+        let { loaderData, errors: errors2 } = dataRouterState;
+        let needsToRunLoader = match.route.loader && !loaderData.hasOwnProperty(match.route.id) && (!errors2 || errors2[match.route.id] === void 0);
+        if (match.route.lazy || needsToRunLoader) {
+          renderFallback = true;
+          if (fallbackIndex >= 0) {
+            renderedMatches = renderedMatches.slice(0, fallbackIndex + 1);
+          } else {
+            renderedMatches = [renderedMatches[0]];
+          }
+          break;
+        }
+      }
+    }
+  }
+  return renderedMatches.reduceRight(
+    (outlet, match, index) => {
+      let error;
+      let shouldRenderHydrateFallback = false;
+      let errorElement = null;
+      let hydrateFallbackElement = null;
+      if (dataRouterState) {
+        error = errors && match.route.id ? errors[match.route.id] : void 0;
+        errorElement = match.route.errorElement || defaultErrorElement;
+        if (renderFallback) {
+          if (fallbackIndex < 0 && index === 0) {
+            warningOnce(
+              "route-fallback",
+              false,
+              "No `HydrateFallback` element provided to render during initial hydration"
+            );
+            shouldRenderHydrateFallback = true;
+            hydrateFallbackElement = null;
+          } else if (fallbackIndex === index) {
+            shouldRenderHydrateFallback = true;
+            hydrateFallbackElement = match.route.hydrateFallbackElement || null;
+          }
+        }
+      }
+      let matches2 = parentMatches.concat(renderedMatches.slice(0, index + 1));
+      let getChildren = () => {
+        let children;
+        if (error) {
+          children = errorElement;
+        } else if (shouldRenderHydrateFallback) {
+          children = hydrateFallbackElement;
+        } else if (match.route.Component) {
+          children = /* @__PURE__ */ React3.createElement(match.route.Component, null);
+        } else if (match.route.element) {
+          children = match.route.element;
+        } else {
+          children = outlet;
+        }
+        return /* @__PURE__ */ React3.createElement(
+          RenderedRoute,
+          {
+            match,
+            routeContext: {
+              outlet,
+              matches: matches2,
+              isDataRoute: dataRouterState != null
+            },
+            children
+          }
+        );
+      };
+      return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /* @__PURE__ */ React3.createElement(
+        RenderErrorBoundary,
+        {
+          location: dataRouterState.location,
+          revalidation: dataRouterState.revalidation,
+          component: errorElement,
+          error,
+          children: getChildren(),
+          routeContext: { outlet: null, matches: matches2, isDataRoute: true },
+          unstable_onError
+        }
+      ) : getChildren();
+    },
+    null
+  );
+}
+function getDataRouterConsoleError(hookName) {
+  return `${hookName} must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.`;
+}
+function useDataRouterContext(hookName) {
+  let ctx = React3.useContext(DataRouterContext);
+  invariant(ctx, getDataRouterConsoleError(hookName));
+  return ctx;
+}
+function useDataRouterState(hookName) {
+  let state = React3.useContext(DataRouterStateContext);
+  invariant(state, getDataRouterConsoleError(hookName));
+  return state;
+}
+function useRouteContext(hookName) {
+  let route = React3.useContext(RouteContext);
+  invariant(route, getDataRouterConsoleError(hookName));
+  return route;
+}
+function useCurrentRouteId(hookName) {
+  let route = useRouteContext(hookName);
+  let thisRoute = route.matches[route.matches.length - 1];
+  invariant(
+    thisRoute.route.id,
+    `${hookName} can only be used on routes that contain a unique "id"`
+  );
+  return thisRoute.route.id;
+}
+function useRouteId() {
+  return useCurrentRouteId("useRouteId" /* UseRouteId */);
+}
+function useRouteError() {
+  let error = React3.useContext(RouteErrorContext);
+  let state = useDataRouterState("useRouteError" /* UseRouteError */);
+  let routeId = useCurrentRouteId("useRouteError" /* UseRouteError */);
+  if (error !== void 0) {
+    return error;
+  }
+  return state.errors?.[routeId];
+}
+function useNavigateStable() {
+  let { router } = useDataRouterContext("useNavigate" /* UseNavigateStable */);
+  let id = useCurrentRouteId("useNavigate" /* UseNavigateStable */);
+  let activeRef = React3.useRef(false);
+  useIsomorphicLayoutEffect(() => {
+    activeRef.current = true;
+  });
+  let navigate = React3.useCallback(
+    async (to, options = {}) => {
+      warning(activeRef.current, navigateEffectWarning);
+      if (!activeRef.current) return;
+      if (typeof to === "number") {
+        router.navigate(to);
+      } else {
+        await router.navigate(to, { fromRouteId: id, ...options });
+      }
+    },
+    [router, id]
+  );
+  return navigate;
+}
+var alreadyWarned = {};
+function warningOnce(key, cond, message) {
+  if (!cond && !alreadyWarned[key]) {
+    alreadyWarned[key] = true;
+    warning(false, message);
+  }
+}
+React3.memo(DataRoutes);
+function DataRoutes({
+  routes,
+  future,
+  state,
+  unstable_onError
+}) {
+  return useRoutesImpl(routes, void 0, state, unstable_onError, future);
+}
+
+// lib/dom/dom.ts
+var defaultMethod = "get";
+var 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);
+}
+var _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;
+}
+var supportedFormEncTypes = /* @__PURE__ */ new Set([
+  "application/x-www-form-urlencoded",
+  "multipart/form-data",
+  "text/plain"
+]);
+function getFormEncType(encType) {
+  if (encType != null && !supportedFormEncTypes.has(encType)) {
+    warning(
+      false,
+      `"${encType}" is not a valid \`encType\` for \`<Form>\`/\`<fetcher.Form>\` and will default to "${defaultEncType}"`
+    );
+    return null;
+  }
+  return encType;
+}
+function getFormSubmissionInfo(target, basename) {
+  let method;
+  let action;
+  let encType;
+  let formData;
+  let body;
+  if (isFormElement(target)) {
+    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>`
+      );
+    }
+    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;
+    formData = new FormData(form, target);
+    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;
+  }
+  if (formData && encType === "text/plain") {
+    body = formData;
+    formData = void 0;
+  }
+  return { action, method: method.toLowerCase(), encType, formData, body };
+}
+Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
+
+// lib/dom/ssr/invariant.ts
+function invariant2(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    throw new Error(message);
+  }
+}
+function singleFetchUrl(reqUrl, basename, extension) {
+  let url = typeof reqUrl === "string" ? new URL(
+    reqUrl,
+    // This can be called during the SSR flow via PrefetchPageLinksImpl so
+    // don't assume window is available
+    typeof window === "undefined" ? "server://singlefetch/" : window.location.origin
+  ) : reqUrl;
+  if (url.pathname === "/") {
+    url.pathname = `_root.${extension}`;
+  } else if (basename && stripBasename(url.pathname, basename) === "/") {
+    url.pathname = `${basename.replace(/\/$/, "")}/_root.${extension}`;
+  } else {
+    url.pathname = `${url.pathname.replace(/\/$/, "")}.${extension}`;
+  }
+  return url;
+}
+
+// lib/dom/ssr/routeModules.ts
+async function loadRouteModule(route, routeModulesCache) {
+  if (route.id in routeModulesCache) {
+    return routeModulesCache[route.id];
+  }
+  try {
+    let routeModule = await import(
+      /* @vite-ignore */
+      /* webpackIgnore: true */
+      route.module
+    );
+    routeModulesCache[route.id] = routeModule;
+    return routeModule;
+  } catch (error) {
+    console.error(
+      `Error loading route module \`${route.module}\`, reloading page...`
+    );
+    console.error(error);
+    if (window.__reactRouterContext && window.__reactRouterContext.isSpaMode && // @ts-expect-error
+    import.meta.hot) {
+      throw error;
+    }
+    window.location.reload();
+    return new Promise(() => {
+    });
+  }
+}
+function isHtmlLinkDescriptor(object) {
+  if (object == null) {
+    return false;
+  }
+  if (object.href == null) {
+    return object.rel === "preload" && typeof object.imageSrcSet === "string" && typeof object.imageSizes === "string";
+  }
+  return typeof object.rel === "string" && typeof object.href === "string";
+}
+async function getKeyedPrefetchLinks(matches, manifest, routeModules) {
+  let links = await Promise.all(
+    matches.map(async (match) => {
+      let route = manifest.routes[match.route.id];
+      if (route) {
+        let mod = await loadRouteModule(route, routeModules);
+        return mod.links ? mod.links() : [];
+      }
+      return [];
+    })
+  );
+  return dedupeLinkDescriptors(
+    links.flat(1).filter(isHtmlLinkDescriptor).filter((link) => link.rel === "stylesheet" || link.rel === "preload").map(
+      (link) => link.rel === "stylesheet" ? { ...link, rel: "prefetch", as: "style" } : { ...link, rel: "prefetch" }
+    )
+  );
+}
+function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, location, mode) {
+  let isNew = (match, index) => {
+    if (!currentMatches[index]) return true;
+    return match.route.id !== currentMatches[index].route.id;
+  };
+  let matchPathChanged = (match, index) => {
+    return (
+      // param change, /users/123 -> /users/456
+      currentMatches[index].pathname !== match.pathname || // splat param changed, which is not present in match.path
+      // e.g. /files/images/avatar.jpg -> files/finances.xls
+      currentMatches[index].route.path?.endsWith("*") && currentMatches[index].params["*"] !== match.params["*"]
+    );
+  };
+  if (mode === "assets") {
+    return nextMatches.filter(
+      (match, index) => isNew(match, index) || matchPathChanged(match, index)
+    );
+  }
+  if (mode === "data") {
+    return nextMatches.filter((match, index) => {
+      let manifestRoute = manifest.routes[match.route.id];
+      if (!manifestRoute || !manifestRoute.hasLoader) {
+        return false;
+      }
+      if (isNew(match, index) || matchPathChanged(match, index)) {
+        return true;
+      }
+      if (match.route.shouldRevalidate) {
+        let routeChoice = match.route.shouldRevalidate({
+          currentUrl: new URL(
+            location.pathname + location.search + location.hash,
+            window.origin
+          ),
+          currentParams: currentMatches[0]?.params || {},
+          nextUrl: new URL(page, window.origin),
+          nextParams: match.params,
+          defaultShouldRevalidate: true
+        });
+        if (typeof routeChoice === "boolean") {
+          return routeChoice;
+        }
+      }
+      return true;
+    });
+  }
+  return [];
+}
+function getModuleLinkHrefs(matches, manifest, { includeHydrateFallback } = {}) {
+  return dedupeHrefs(
+    matches.map((match) => {
+      let route = manifest.routes[match.route.id];
+      if (!route) return [];
+      let hrefs = [route.module];
+      if (route.clientActionModule) {
+        hrefs = hrefs.concat(route.clientActionModule);
+      }
+      if (route.clientLoaderModule) {
+        hrefs = hrefs.concat(route.clientLoaderModule);
+      }
+      if (includeHydrateFallback && route.hydrateFallbackModule) {
+        hrefs = hrefs.concat(route.hydrateFallbackModule);
+      }
+      if (route.imports) {
+        hrefs = hrefs.concat(route.imports);
+      }
+      return hrefs;
+    }).flat(1)
+  );
+}
+function dedupeHrefs(hrefs) {
+  return [...new Set(hrefs)];
+}
+function sortKeys(obj) {
+  let sorted = {};
+  let keys = Object.keys(obj).sort();
+  for (let key of keys) {
+    sorted[key] = obj[key];
+  }
+  return sorted;
+}
+function dedupeLinkDescriptors(descriptors, preloads) {
+  let set = /* @__PURE__ */ new Set();
+  new Set(preloads);
+  return descriptors.reduce((deduped, descriptor) => {
+    let key = JSON.stringify(sortKeys(descriptor));
+    if (!set.has(key)) {
+      set.add(key);
+      deduped.push({ key, link: descriptor });
+    }
+    return deduped;
+  }, []);
+}
+
+// lib/dom/ssr/components.tsx
+function useDataRouterContext2() {
+  let context = React3.useContext(DataRouterContext);
+  invariant2(
+    context,
+    "You must render this element inside a <DataRouterContext.Provider> element"
+  );
+  return context;
+}
+function useDataRouterStateContext() {
+  let context = React3.useContext(DataRouterStateContext);
+  invariant2(
+    context,
+    "You must render this element inside a <DataRouterStateContext.Provider> element"
+  );
+  return context;
+}
+var FrameworkContext = React3.createContext(void 0);
+FrameworkContext.displayName = "FrameworkContext";
+function useFrameworkContext() {
+  let context = React3.useContext(FrameworkContext);
+  invariant2(
+    context,
+    "You must render this element inside a <HydratedRouter> element"
+  );
+  return context;
+}
+function usePrefetchBehavior(prefetch, theirElementProps) {
+  let frameworkContext = React3.useContext(FrameworkContext);
+  let [maybePrefetch, setMaybePrefetch] = React3.useState(false);
+  let [shouldPrefetch, setShouldPrefetch] = React3.useState(false);
+  let { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
+  let ref = React3.useRef(null);
+  React3.useEffect(() => {
+    if (prefetch === "render") {
+      setShouldPrefetch(true);
+    }
+    if (prefetch === "viewport") {
+      let callback = (entries) => {
+        entries.forEach((entry) => {
+          setShouldPrefetch(entry.isIntersecting);
+        });
+      };
+      let observer = new IntersectionObserver(callback, { threshold: 0.5 });
+      if (ref.current) observer.observe(ref.current);
+      return () => {
+        observer.disconnect();
+      };
+    }
+  }, [prefetch]);
+  React3.useEffect(() => {
+    if (maybePrefetch) {
+      let id = setTimeout(() => {
+        setShouldPrefetch(true);
+      }, 100);
+      return () => {
+        clearTimeout(id);
+      };
+    }
+  }, [maybePrefetch]);
+  let setIntent = () => {
+    setMaybePrefetch(true);
+  };
+  let cancelIntent = () => {
+    setMaybePrefetch(false);
+    setShouldPrefetch(false);
+  };
+  if (!frameworkContext) {
+    return [false, ref, {}];
+  }
+  if (prefetch !== "intent") {
+    return [shouldPrefetch, ref, {}];
+  }
+  return [
+    shouldPrefetch,
+    ref,
+    {
+      onFocus: composeEventHandlers(onFocus, setIntent),
+      onBlur: composeEventHandlers(onBlur, cancelIntent),
+      onMouseEnter: composeEventHandlers(onMouseEnter, setIntent),
+      onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
+      onTouchStart: composeEventHandlers(onTouchStart, setIntent)
+    }
+  ];
+}
+function composeEventHandlers(theirHandler, ourHandler) {
+  return (event) => {
+    theirHandler && theirHandler(event);
+    if (!event.defaultPrevented) {
+      ourHandler(event);
+    }
+  };
+}
+function PrefetchPageLinks({ page, ...linkProps }) {
+  let { router } = useDataRouterContext2();
+  let matches = React3.useMemo(
+    () => matchRoutes(router.routes, page, router.basename),
+    [router.routes, page, router.basename]
+  );
+  if (!matches) {
+    return null;
+  }
+  return /* @__PURE__ */ React3.createElement(PrefetchPageLinksImpl, { page, matches, ...linkProps });
+}
+function useKeyedPrefetchLinks(matches) {
+  let { manifest, routeModules } = useFrameworkContext();
+  let [keyedPrefetchLinks, setKeyedPrefetchLinks] = React3.useState([]);
+  React3.useEffect(() => {
+    let interrupted = false;
+    void getKeyedPrefetchLinks(matches, manifest, routeModules).then(
+      (links) => {
+        if (!interrupted) {
+          setKeyedPrefetchLinks(links);
+        }
+      }
+    );
+    return () => {
+      interrupted = true;
+    };
+  }, [matches, manifest, routeModules]);
+  return keyedPrefetchLinks;
+}
+function PrefetchPageLinksImpl({
+  page,
+  matches: nextMatches,
+  ...linkProps
+}) {
+  let location = useLocation();
+  let { manifest, routeModules } = useFrameworkContext();
+  let { basename } = useDataRouterContext2();
+  let { loaderData, matches } = useDataRouterStateContext();
+  let newMatchesForData = React3.useMemo(
+    () => getNewMatchesForLinks(
+      page,
+      nextMatches,
+      matches,
+      manifest,
+      location,
+      "data"
+    ),
+    [page, nextMatches, matches, manifest, location]
+  );
+  let newMatchesForAssets = React3.useMemo(
+    () => getNewMatchesForLinks(
+      page,
+      nextMatches,
+      matches,
+      manifest,
+      location,
+      "assets"
+    ),
+    [page, nextMatches, matches, manifest, location]
+  );
+  let dataHrefs = React3.useMemo(() => {
+    if (page === location.pathname + location.search + location.hash) {
+      return [];
+    }
+    let routesParams = /* @__PURE__ */ new Set();
+    let foundOptOutRoute = false;
+    nextMatches.forEach((m) => {
+      let manifestRoute = manifest.routes[m.route.id];
+      if (!manifestRoute || !manifestRoute.hasLoader) {
+        return;
+      }
+      if (!newMatchesForData.some((m2) => m2.route.id === m.route.id) && m.route.id in loaderData && routeModules[m.route.id]?.shouldRevalidate) {
+        foundOptOutRoute = true;
+      } else if (manifestRoute.hasClientLoader) {
+        foundOptOutRoute = true;
+      } else {
+        routesParams.add(m.route.id);
+      }
+    });
+    if (routesParams.size === 0) {
+      return [];
+    }
+    let url = singleFetchUrl(page, basename, "data");
+    if (foundOptOutRoute && routesParams.size > 0) {
+      url.searchParams.set(
+        "_routes",
+        nextMatches.filter((m) => routesParams.has(m.route.id)).map((m) => m.route.id).join(",")
+      );
+    }
+    return [url.pathname + url.search];
+  }, [
+    basename,
+    loaderData,
+    location,
+    manifest,
+    newMatchesForData,
+    nextMatches,
+    page,
+    routeModules
+  ]);
+  let moduleHrefs = React3.useMemo(
+    () => getModuleLinkHrefs(newMatchesForAssets, manifest),
+    [newMatchesForAssets, manifest]
+  );
+  let keyedPrefetchLinks = useKeyedPrefetchLinks(newMatchesForAssets);
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, dataHrefs.map((href) => /* @__PURE__ */ React3.createElement("link", { key: href, rel: "prefetch", as: "fetch", href, ...linkProps })), moduleHrefs.map((href) => /* @__PURE__ */ React3.createElement("link", { key: href, rel: "modulepreload", href, ...linkProps })), keyedPrefetchLinks.map(({ key, link }) => (
+    // these don't spread `linkProps` because they are full link descriptors
+    // already with their own props
+    /* @__PURE__ */ React3.createElement("link", { key, nonce: linkProps.nonce, ...link })
+  )));
+}
+function mergeRefs(...refs) {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        ref.current = value;
+      }
+    });
+  };
+}
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+try {
+  if (isBrowser) {
+    window.__reactRouterVersion = // @ts-expect-error
+    "7.8.2";
+  }
+} catch (e) {
+}
+var ABSOLUTE_URL_REGEX2 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+var Link = React3.forwardRef(
+  function LinkWithRef({
+    onClick,
+    discover = "render",
+    prefetch = "none",
+    relative,
+    reloadDocument,
+    replace: replace2,
+    state,
+    target,
+    to,
+    preventScrollReset,
+    viewTransition,
+    ...rest
+  }, forwardedRef) {
+    let { basename } = React3.useContext(NavigationContext);
+    let isAbsolute = typeof to === "string" && ABSOLUTE_URL_REGEX2.test(to);
+    let absoluteHref;
+    let isExternal = false;
+    if (typeof to === "string" && isAbsolute) {
+      absoluteHref = to;
+      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) {
+            to = path + targetUrl.search + targetUrl.hash;
+          } else {
+            isExternal = true;
+          }
+        } catch (e) {
+          warning(
+            false,
+            `<Link to="${to}"> contains an invalid URL which will probably break when clicked - please update to a valid URL path.`
+          );
+        }
+      }
+    }
+    let href = useHref(to, { relative });
+    let [shouldPrefetch, prefetchRef, prefetchHandlers] = usePrefetchBehavior(
+      prefetch,
+      rest
+    );
+    let internalOnClick = useLinkClickHandler(to, {
+      replace: replace2,
+      state,
+      target,
+      preventScrollReset,
+      relative,
+      viewTransition
+    });
+    function handleClick(event) {
+      if (onClick) onClick(event);
+      if (!event.defaultPrevented) {
+        internalOnClick(event);
+      }
+    }
+    let link = (
+      // eslint-disable-next-line jsx-a11y/anchor-has-content
+      /* @__PURE__ */ React3.createElement(
+        "a",
+        {
+          ...rest,
+          ...prefetchHandlers,
+          href: absoluteHref || href,
+          onClick: isExternal || reloadDocument ? onClick : handleClick,
+          ref: mergeRefs(forwardedRef, prefetchRef),
+          target,
+          "data-discover": !isAbsolute && discover === "render" ? "true" : void 0
+        }
+      )
+    );
+    return shouldPrefetch && !isAbsolute ? /* @__PURE__ */ React3.createElement(React3.Fragment, null, link, /* @__PURE__ */ React3.createElement(PrefetchPageLinks, { page: href })) : link;
+  }
+);
+Link.displayName = "Link";
+var NavLink = React3.forwardRef(
+  function NavLinkWithRef({
+    "aria-current": ariaCurrentProp = "page",
+    caseSensitive = false,
+    className: classNameProp = "",
+    end = false,
+    style: styleProp,
+    to,
+    viewTransition,
+    children,
+    ...rest
+  }, ref) {
+    let path = useResolvedPath(to, { relative: rest.relative });
+    let location = useLocation();
+    let routerState = React3.useContext(DataRouterStateContext);
+    let { navigator, basename } = React3.useContext(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;
+    }
+    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 : void 0;
+    let className;
+    if (typeof classNameProp === "function") {
+      className = classNameProp(renderProps);
+    } else {
+      className = [
+        classNameProp,
+        isActive ? "active" : null,
+        isPending ? "pending" : null,
+        isTransitioning ? "transitioning" : null
+      ].filter(Boolean).join(" ");
+    }
+    let style = typeof styleProp === "function" ? styleProp(renderProps) : styleProp;
+    return /* @__PURE__ */ React3.createElement(
+      Link,
+      {
+        ...rest,
+        "aria-current": ariaCurrent,
+        className,
+        ref,
+        style,
+        to,
+        viewTransition
+      },
+      typeof children === "function" ? children(renderProps) : children
+    );
+  }
+);
+NavLink.displayName = "NavLink";
+var Form = React3.forwardRef(
+  ({
+    discover = "render",
+    fetcherKey,
+    navigate,
+    reloadDocument,
+    replace: replace2,
+    state,
+    method = defaultMethod,
+    action,
+    onSubmit,
+    relative,
+    preventScrollReset,
+    viewTransition,
+    ...props
+  }, forwardedRef) => {
+    let submit = useSubmit();
+    let formAction = useFormAction(action, { relative });
+    let formMethod = method.toLowerCase() === "get" ? "get" : "post";
+    let isAbsolute = typeof action === "string" && ABSOLUTE_URL_REGEX2.test(action);
+    let submitHandler = (event) => {
+      onSubmit && onSubmit(event);
+      if (event.defaultPrevented) return;
+      event.preventDefault();
+      let submitter = event.nativeEvent.submitter;
+      let submitMethod = submitter?.getAttribute("formmethod") || method;
+      submit(submitter || event.currentTarget, {
+        fetcherKey,
+        method: submitMethod,
+        navigate,
+        replace: replace2,
+        state,
+        relative,
+        preventScrollReset,
+        viewTransition
+      });
+    };
+    return /* @__PURE__ */ React3.createElement(
+      "form",
+      {
+        ref: forwardedRef,
+        method: formMethod,
+        action: formAction,
+        onSubmit: reloadDocument ? onSubmit : submitHandler,
+        ...props,
+        "data-discover": !isAbsolute && discover === "render" ? "true" : void 0
+      }
+    );
+  }
+);
+Form.displayName = "Form";
+function getDataRouterConsoleError2(hookName) {
+  return `${hookName} must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.`;
+}
+function useDataRouterContext3(hookName) {
+  let ctx = React3.useContext(DataRouterContext);
+  invariant(ctx, getDataRouterConsoleError2(hookName));
+  return ctx;
+}
+function useLinkClickHandler(to, {
+  target,
+  replace: replaceProp,
+  state,
+  preventScrollReset,
+  relative,
+  viewTransition
+} = {}) {
+  let navigate = useNavigate();
+  let location = useLocation();
+  let path = useResolvedPath(to, { relative });
+  return React3.useCallback(
+    (event) => {
+      if (shouldProcessLinkClick(event, target)) {
+        event.preventDefault();
+        let replace2 = replaceProp !== void 0 ? replaceProp : createPath(location) === createPath(path);
+        navigate(to, {
+          replace: replace2,
+          state,
+          preventScrollReset,
+          relative,
+          viewTransition
+        });
+      }
+    },
+    [
+      location,
+      navigate,
+      path,
+      replaceProp,
+      state,
+      target,
+      to,
+      preventScrollReset,
+      relative,
+      viewTransition
+    ]
+  );
+}
+var fetcherId = 0;
+var getUniqueFetcherId = () => `__${String(++fetcherId)}__`;
+function useSubmit() {
+  let { router } = useDataRouterContext3("useSubmit" /* UseSubmit */);
+  let { basename } = React3.useContext(NavigationContext);
+  let currentRouteId = useRouteId();
+  return React3.useCallback(
+    async (target, options = {}) => {
+      let { action, method, encType, formData, body } = getFormSubmissionInfo(
+        target,
+        basename
+      );
+      if (options.navigate === false) {
+        let key = options.fetcherKey || getUniqueFetcherId();
+        await router.fetch(key, currentRouteId, options.action || action, {
+          preventScrollReset: options.preventScrollReset,
+          formData,
+          body,
+          formMethod: options.method || method,
+          formEncType: options.encType || encType,
+          flushSync: options.flushSync
+        });
+      } else {
+        await 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]
+  );
+}
+function useFormAction(action, { relative } = {}) {
+  let { basename } = React3.useContext(NavigationContext);
+  let routeContext = React3.useContext(RouteContext);
+  invariant(routeContext, "useFormAction must be used inside a RouteContext");
+  let [match] = routeContext.matches.slice(-1);
+  let path = { ...useResolvedPath(action ? action : ".", { relative }) };
+  let location = useLocation();
+  if (action == null) {
+    path.search = location.search;
+    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 (basename !== "/") {
+    path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+  }
+  return createPath(path);
+}
+function useViewTransitionState(to, { relative } = {}) {
+  let vtContext = React3.useContext(ViewTransitionContext);
+  invariant(
+    vtContext != null,
+    "`useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`.  Did you accidentally import `RouterProvider` from `react-router`?"
+  );
+  let { basename } = useDataRouterContext3(
+    "useViewTransitionState" /* useViewTransitionState */
+  );
+  let path = useResolvedPath(to, { 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;
+  return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;
+}
+
 var _excluded$6 = ["color"];
 var ExternalarrowMd = function ExternalarrowMd(_ref) {
   var _ref$color = _ref.color,
@@ -65841,7 +67549,7 @@ function RuledGrid(_ref) {
   var columns = _ref.columns,
     children = _ref.children,
     rest = _objectWithoutProperties(_ref, _excluded$5);
-  var childrenArray = React__default.Children.toArray(children);
+  var childrenArray = React3__default.Children.toArray(children);
   return jsx(Grid, _objectSpread2(_objectSpread2({
     templateColumns: "repeat(".concat(columns, ", 1fr)"),
     border: "1px solid",
@@ -65873,10 +67581,6 @@ function HelloPage(_ref) {
     label: "Contact Us",
     href: "/contact-us",
     isExternal: false
-  }, {
-    label: "About Us",
-    href: "/about",
-    isExternal: false
   }, {
     label: "Changelog",
     href: "/analytics/changelog",
@@ -65890,114 +67594,141 @@ function HelloPage(_ref) {
     href: "https://www.youtube.com/watch?v=fuZLWeku6fw&list=PLwoJzeXHsBW6bAHmPz04RtWvpg_09-vqi",
     isExternal: true
   }];
-  return jsx(Box, {
+  return jsx(VStack, {
     w: "full",
-    h: "100%",
-    overflowY: "auto",
-    overflowX: "hidden",
-    p: 4,
-    children: jsxs(VStack, {
-      align: "stretch",
-      justify: "flex-end",
-      gap: 4,
-      height: "full",
-      children: [jsxs(Flex, {
-        flexDirection: "column",
-        justifyContent: "flex-end",
-        flexShrink: 0,
-        paddingTop: "48px",
-        children: [jsx(Text, {
-          color: "#2BCFA1",
-          fontSize: "3xl",
-          fontWeight: "bold",
-          lineHeight: "40px",
-          children: "Hi ".concat(userName ? userName : "", " \uD83D\uDC4B\uD83C\uDFFB")
-        }), jsx(Text, {
-          color: "white",
-          fontSize: "3xl",
-          fontWeight: "bold",
-          lineHeight: "40px",
-          children: "How can I help?"
-        })]
-      }), jsxs(RuledGrid, {
-        columns: 1,
-        borderRadius: 16,
-        bg: "#222",
-        overflow: "hidden",
-        children: [jsxs(VStack, {
-          align: "stretch",
-          gap: 3,
-          p: 4,
-          children: [jsx(Box, {
-            p: 2.5,
-            w: "fit-content",
-            bg: "rgba(43, 207, 161, 0.1)",
-            border: "1px solid",
-            borderColor: "rgba(43, 207, 161, 0.1)",
-            borderRadius: "lg",
-            children: jsx(AIMd, {
-              color: "#2BCFA1"
-            })
-          }), jsxs(VStack, {
-            gap: 0.5,
+    h: "full",
+    minH: 0,
+    spacing: 0,
+    flex: 1,
+    children: jsx(Box, {
+      flex: 1,
+      minH: 0,
+      w: "full",
+      overflowY: "auto",
+      overflowX: "hidden",
+      p: 4,
+      css: {
+        "&::-webkit-scrollbar": {
+          width: "6px"
+        },
+        "&::-webkit-scrollbar-track": {
+          background: "rgba(255, 255, 255, 0.1)",
+          borderRadius: "3px"
+        },
+        "&::-webkit-scrollbar-thumb": {
+          background: "rgba(255, 255, 255, 0.3)",
+          borderRadius: "3px"
+        },
+        "&::-webkit-scrollbar-thumb:hover": {
+          background: "rgba(255, 255, 255, 0.5)"
+        },
+        scrollBehavior: "smooth",
+        WebkitOverflowScrolling: "touch"
+      },
+      children: jsxs(VStack, {
+        align: "stretch",
+        justify: "flex-start",
+        gap: 4,
+        children: [jsxs(Flex, {
+          flexDirection: "column",
+          justifyContent: "flex-end",
+          flexShrink: 0,
+          paddingTop: "48px",
+          children: [jsx(Text, {
+            color: "#2BCFA1",
+            fontSize: "3xl",
+            fontWeight: "bold",
+            lineHeight: "40px",
+            children: "Hi ".concat(userName ? userName : "", " \uD83D\uDC4B\uD83C\uDFFB")
+          }), jsx(Text, {
+            color: "white",
+            fontSize: "3xl",
+            fontWeight: "bold",
+            lineHeight: "40px",
+            children: "How can I help?"
+          })]
+        }), jsxs(RuledGrid, {
+          columns: 1,
+          borderRadius: 16,
+          bg: "#222",
+          overflow: "hidden",
+          children: [jsxs(VStack, {
             align: "stretch",
-            children: [jsx(Text, {
-              color: "white",
-              fontSize: "base",
-              fontWeight: "medium",
-              lineHeight: "normal",
-              children: "AI Merchant Assistant"
-            }), jsx(Text, {
-              color: "#737373",
-              fontSize: "sm",
-              fontWeight: "normal",
-              lineHeight: "tight",
-              children: "I can help with your shop setup, payment and more"
+            gap: 3,
+            p: 4,
+            children: [jsx(Box, {
+              p: 2.5,
+              w: "fit-content",
+              bg: "rgba(43, 207, 161, 0.1)",
+              border: "1px solid",
+              borderColor: "rgba(43, 207, 161, 0.1)",
+              borderRadius: "lg",
+              children: jsx(AIMd, {
+                color: "#2BCFA1"
+              })
+            }), jsxs(VStack, {
+              gap: 0.5,
+              align: "stretch",
+              children: [jsx(Text, {
+                color: "white",
+                fontSize: "base",
+                fontWeight: "medium",
+                lineHeight: "normal",
+                children: "AI Merchant Assistant"
+              }), jsx(Text, {
+                color: "#737373",
+                fontSize: "sm",
+                fontWeight: "normal",
+                lineHeight: "tight",
+                children: "I can help with your shop setup, payment and more"
+              })]
             })]
-          })]
-        }), jsx(Button, {
-          w: "full",
-          padding: "10px 14px",
-          borderRadius: 0,
-          variant: "ghost",
-          _hover: {
-            bg: "rgba(43, 207, 161, 0.1)"
-          },
-          fontSize: 14,
-          fontWeight: 500,
-          color: "#2BCFA1",
-          onClick: onStartChat,
-          isLoading: isStartingChat,
-          isDisabled: isStartingChat,
-          _disabled: {
-            color: "#525252",
-            cursor: "not-allowed"
-          },
-          children: "Start Chat"
-        })]
-      }), jsx(RuledGrid, {
-        columns: 1,
-        borderRadius: 16,
-        bg: "#222",
-        children: navigationItems.map(function (item, index) {
-          return jsxs(Link, {
-            display: "flex",
-            justifyContent: "space-between",
-            alignItems: "center",
-            gap: 4,
-            padding: "12px 16px",
+          }), jsx(Button, {
+            w: "full",
+            padding: "10px 14px",
+            borderRadius: 0,
+            variant: "ghost",
+            _hover: {
+              bg: "rgba(43, 207, 161, 0.1)"
+            },
             fontSize: 14,
             fontWeight: 500,
-            color: "white",
-            textDecoration: "none",
-            href: item.href,
-            isExternal: item.isExternal,
-            children: [item.label, jsx(ExternalarrowMd, {
-              color: "white"
-            })]
-          }, index);
-        })
-      })]
+            color: "#2BCFA1",
+            onClick: onStartChat,
+            isLoading: isStartingChat,
+            isDisabled: isStartingChat,
+            _disabled: {
+              color: "#525252",
+              cursor: "not-allowed"
+            },
+            children: "Start Chat"
+          })]
+        }), jsx(RuledGrid, {
+          columns: 1,
+          borderRadius: 16,
+          bg: "#222",
+          children: navigationItems.map(function (item, index) {
+            return jsxs(Link$1, {
+              display: "flex",
+              justifyContent: "space-between",
+              alignItems: "center",
+              gap: 4,
+              padding: "12px 16px",
+              fontSize: 14,
+              fontWeight: 500,
+              color: "white",
+              textDecoration: "none",
+              as: item.isExternal ? undefined : Link,
+              to: item.isExternal ? undefined : item.href,
+              href: item.isExternal ? item.href : undefined,
+              isExternal: item.isExternal,
+              children: [item.label, jsx(ExternalarrowMd, {
+                color: "white"
+              })]
+            }, index);
+          })
+        })]
+      })
     })
   });
 }
@@ -66024,6 +67755,7 @@ function ChatDrawer(_ref) {
       flexDirection: "column",
       position: "relative",
       overflow: "hidden",
+      minH: 0,
       maxW: {
         base: "100%",
         md: "420px"
@@ -66168,29 +67900,31 @@ var TooltipMd = function TooltipMd(_ref) {
 };
 
 var _excluded = ["showArrow", "children", "disabled", "portalled", "content", "portalRef", "placement"];
-var Tooltip = /*#__PURE__*/React.forwardRef(function Tooltip(_ref2, _ref) {
+var Tooltip = /*#__PURE__*/React3.forwardRef(function Tooltip(_ref2, _ref) {
   var showArrow = _ref2.showArrow,
     children = _ref2.children,
     disabled = _ref2.disabled;
     _ref2.portalled;
-    var content = _ref2.content,
-    portalRef = _ref2.portalRef,
-    placement = _ref2.placement,
+    var content = _ref2.content;
+    _ref2.portalRef;
+    var placement = _ref2.placement,
     rest = _objectWithoutProperties(_ref2, _excluded);
   if (disabled) return jsx(Fragment, {
     children: children
   });
   return jsx(Tooltip$1, _objectSpread2(_objectSpread2({
+    border: "1px solid",
+    borderColor: "#292929",
+    borderRadius: "6px",
+    padding: "4px 16px",
+    backgroundColor: "#1c1c1c",
+    color: "white",
+    placement: placement !== null && placement !== void 0 ? placement : "auto",
     label: content,
     hasArrow: !!showArrow,
-    portalProps: {
-      containerRef: portalRef
-    },
-    placement: placement
+    shouldWrapChildren: true
   }, rest), {}, {
-    children: jsx("span", {
-      children: children
-    })
+    children: children
   }));
 });
 
@@ -66433,6 +68167,9 @@ function Chatbot(_ref) {
         flex: 1,
         overflow: "hidden",
         p: 0,
+        minH: 0,
+        display: "flex",
+        flexDirection: "column",
         children: currentView === "hello" ? jsx(HelloPage, {
           userName: user === null || user === void 0 ? void 0 : user.name,
           onStartChat: handleStartChat,