pallote-react 0.14.6 → 0.15.0

package/index.js

@@ -1,4 +1,5 @@
-import React, { useState, useEffect, useRef, createContext, useContext } from 'react';
+import * as React from 'react';
+import React__default, { useState, useEffect, useRef, createContext, useContext } from 'react';
 import classnames from 'classnames';
 import PropTypes from 'prop-types';
 import { createPortal } from 'react-dom';
@@ -26,7 +27,7 @@ const Color = ({
     [`fill-${fill}`]: fill,
     [`stroke-${stroke}`]: stroke
   });
-  return /*#__PURE__*/React.cloneElement(children, {
+  return /*#__PURE__*/React__default.cloneElement(children, {
     className: childClassName,
     style: {
       ...children.props.style,
@@ -44,11 +45,6 @@ Color.propTypes = {
   children: PropTypes.node
 };
 
-var Color$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Color: Color
-});
-
 const viewportSizes = {
   'mobile-sm': 375,
   'mobile': 576,
@@ -81,7 +77,7 @@ const Display = ({
     window.addEventListener('resize', updateMedia);
     return () => window.removeEventListener('resize', updateMedia);
   }, [show, hide]);
-  return /*#__PURE__*/React.createElement(React.Fragment, null, isDisplayed ? children : null);
+  return /*#__PURE__*/React__default.createElement(React__default.Fragment, null, isDisplayed ? children : null);
 };
 Display.propTypes = {
   show: PropTypes.oneOf(['mobile-sm', 'mobile', 'tablet', 'laptop', 'desktop', 'touch']),
@@ -89,11 +85,6 @@ Display.propTypes = {
   children: PropTypes.node
 };
 
-var Display$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Display: Display
-});
-
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function (n) {
     for (var e = 1; e < arguments.length; e++) {
@@ -122,7 +113,7 @@ const Grid = ({
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames('flex', {
       'flex-wrap': wrap,
       [`direction-${direction}`]: direction,
@@ -157,11 +148,6 @@ Grid.propTypes = {
   children: PropTypes.node
 };
 
-var Grid$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Grid: Grid
-});
-
 const Text = ({
   variant,
   align,
@@ -178,7 +164,7 @@ const Text = ({
   ...props
 }) => {
   const Component = component || 'p';
-  return /*#__PURE__*/React.createElement(Component, _extends({
+  return /*#__PURE__*/React__default.createElement(Component, _extends({
     className: classnames([{
       [`${variant}`]: variant,
       [`text-${align}`]: align,
@@ -207,11 +193,6 @@ Text.propTypes = {
   children: PropTypes.node
 };
 
-var Text$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Text: Text
-});
-
 const Alert = ({
   color = 'success',
   variant = 'toast',
@@ -240,7 +221,7 @@ const Alert = ({
   const onAnimationEnd = () => {
     if (!show) setRender(false);
   };
-  let alert = /*#__PURE__*/React.createElement("div", _extends({
+  let alert = /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['alert', {
       [`alert-${color}`]: color,
       [`alert-${variant}`]: variant,
@@ -250,22 +231,22 @@ const Alert = ({
       'alert-noIcon': noIcon
     }, className]),
     onAnimationEnd: onAnimationEnd
-  }, props), /*#__PURE__*/React.createElement("div", {
+  }, props), /*#__PURE__*/React__default.createElement("div", {
     className: classnames('alert_content')
-  }, title ? /*#__PURE__*/React.createElement(Text, {
+  }, title ? /*#__PURE__*/React__default.createElement(Text, {
     className: classnames('alert_title'),
     variant: dense ? 'caption' : 'body',
     weight: "bold"
-  }, title) : null, subtitle ? /*#__PURE__*/React.createElement(Text, {
+  }, title) : null, subtitle ? /*#__PURE__*/React__default.createElement(Text, {
     variant: dense ? 'overline' : 'caption',
     className: classnames('alert_subtitle')
-  }, subtitle) : null), onClose ? /*#__PURE__*/React.createElement(X, {
+  }, subtitle) : null), onClose ? /*#__PURE__*/React__default.createElement(X, {
     className: classnames('alert_close'),
     onClick: onClose,
     size: dense ? 14 : 16
   }) : null);
   if (variant === 'notice') {
-    return /*#__PURE__*/React.createElement(React.Fragment, null, alert);
+    return /*#__PURE__*/React__default.createElement(React__default.Fragment, null, alert);
   } else {
     return /*#__PURE__*/createPortal(shouldRender && alert, container);
   }
@@ -282,26 +263,21 @@ Alert.propTypes = {
   className: PropTypes.node
 };
 
-var Alert$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Alert: Alert
-});
-
 const Breadcrumbs = ({
   items,
   separator = "slash",
   className
-}) => /*#__PURE__*/React.createElement("nav", {
+}) => /*#__PURE__*/React__default.createElement("nav", {
   "aria-label": "breadcrumbs",
   className: classnames(['breadcrumbs', {
     [`breadcrumbs-${separator}`]: separator
   }, className])
-}, /*#__PURE__*/React.createElement("ol", null, items.map((item, index) => /*#__PURE__*/React.createElement("li", {
+}, /*#__PURE__*/React__default.createElement("ol", null, items.map((item, index) => /*#__PURE__*/React__default.createElement("li", {
   key: index,
   className: "breadcrumbs_item"
-}, index === items.length - 1 ? /*#__PURE__*/React.createElement("p", {
+}, index === items.length - 1 ? /*#__PURE__*/React__default.createElement("p", {
   "aria-current": "page"
-}, item.label) : /*#__PURE__*/React.createElement("a", {
+}, item.label) : /*#__PURE__*/React__default.createElement("a", {
   href: item.href
 }, item.label)))));
 Breadcrumbs.propTypes = {
@@ -310,12 +286,7 @@ Breadcrumbs.propTypes = {
   className: PropTypes.node
 };
 
-var Breadcrumbs$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Breadcrumbs: Breadcrumbs
-});
-
-const Button = /*#__PURE__*/React.forwardRef(({
+const Button = /*#__PURE__*/React__default.forwardRef(({
   component = 'button',
   kind,
   variant = 'fill',
@@ -334,9 +305,9 @@ const Button = /*#__PURE__*/React.forwardRef(({
   if (kind === 'icon') {
     content = children;
   } else {
-    content = /*#__PURE__*/React.createElement(React.Fragment, null, iconLeft && iconLeft, children, iconRight && iconRight);
+    content = /*#__PURE__*/React__default.createElement(React__default.Fragment, null, iconLeft && iconLeft, children, iconRight && iconRight);
   }
-  return /*#__PURE__*/React.createElement(Component, _extends({
+  return /*#__PURE__*/React__default.createElement(Component, _extends({
     className: classnames(['button', {
       [`button-${size}`]: size,
       [`button-${color}`]: color,
@@ -364,11 +335,6 @@ Button.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Button$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Button: Button
-});
-
 const Buttons = ({
   direction = 'landscape',
   fullWidth,
@@ -377,7 +343,7 @@ const Buttons = ({
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['buttons', {
       [`buttons-${direction}`]: direction,
       'buttons-fullWidth': fullWidth,
@@ -393,11 +359,6 @@ Buttons.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Buttons$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Buttons: Buttons
-});
-
 const Card = ({
   size = 'md',
   fill = 'paper',
@@ -409,9 +370,9 @@ const Card = ({
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement(Color, {
+  return /*#__PURE__*/React__default.createElement(Color, {
     fill: transparent ? null : fill
-  }, /*#__PURE__*/React.createElement("div", _extends({
+  }, /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['card', {
       [`card-${size}`]: size,
       [`card-${direction}`]: direction,
@@ -432,18 +393,13 @@ Card.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Card$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Card: Card
-});
-
 const CardActions = ({
   direction,
   className,
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['card_actions', {
       [`card_actions-${direction}`]: direction
     }, className])
@@ -455,18 +411,13 @@ CardActions.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var CardActions$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  CardActions: CardActions
-});
-
 const CardContent = ({
   fullWidth,
   className,
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['card_content', {
       'card_content-fullWidth': fullWidth
     }, className])
@@ -478,11 +429,6 @@ CardContent.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var CardContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  CardContent: CardContent
-});
-
 const CardHeader = ({
   label,
   title,
@@ -491,15 +437,15 @@ const CardHeader = ({
   className,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['card_header', className])
-  }, props), actions && /*#__PURE__*/React.createElement("div", {
+  }, props), actions && /*#__PURE__*/React__default.createElement("div", {
     className: "card_headerActions"
-  }, actions), label ? /*#__PURE__*/React.createElement(Text, {
+  }, actions), label ? /*#__PURE__*/React__default.createElement(Text, {
     className: classnames('card_label')
-  }, label) : null, /*#__PURE__*/React.createElement(Text, {
+  }, label) : null, /*#__PURE__*/React__default.createElement(Text, {
     className: classnames('card_title')
-  }, title), subtitle ? /*#__PURE__*/React.createElement(Text, {
+  }, title), subtitle ? /*#__PURE__*/React__default.createElement(Text, {
     className: classnames('card_subtitle')
   }, subtitle) : null);
 };
@@ -512,11 +458,6 @@ CardHeader.propTypes = {
   children: PropTypes.node
 };
 
-var CardHeader$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  CardHeader: CardHeader
-});
-
 const CardMedia = ({
   width,
   height,
@@ -525,11 +466,11 @@ const CardMedia = ({
   className,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['card_media', {
       'card_media-fullWidth': fullWidth
     }, className])
-  }, props), /*#__PURE__*/React.createElement("div", {
+  }, props), /*#__PURE__*/React__default.createElement("div", {
     className: 'card_mediaInner',
     style: {
       width: width + 'px',
@@ -546,11 +487,6 @@ CardMedia.propTypes = {
   className: PropTypes.node
 };
 
-var CardMedia$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  CardMedia: CardMedia
-});
-
 const Checkbox = ({
   id,
   value,
@@ -561,11 +497,11 @@ const Checkbox = ({
   className,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['checkbox', {
       'checkbox-disabled': disabled
     }, className])
-  }, /*#__PURE__*/React.createElement("input", _extends({
+  }, /*#__PURE__*/React__default.createElement("input", _extends({
     className: classnames('checkbox_control'),
     type: "checkbox",
     name: id,
@@ -575,7 +511,7 @@ const Checkbox = ({
     "aria-checked": checked,
     disabled: disabled,
     required: !(disabled || optional)
-  }, props)), /*#__PURE__*/React.createElement("label", {
+  }, props)), /*#__PURE__*/React__default.createElement("label", {
     className: classnames('checkbox_label'),
     htmlFor: id
   }, label));
@@ -590,11 +526,6 @@ Checkbox.propTypes = {
   className: PropTypes.node
 };
 
-var Checkbox$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Checkbox: Checkbox
-});
-
 const InputLabel = ({
   isLegend = false,
   htmlFor,
@@ -603,14 +534,14 @@ const InputLabel = ({
   error
 }) => {
   const LabelTag = isLegend ? 'legend' : 'label';
-  return /*#__PURE__*/React.createElement(React.Fragment, null, label && /*#__PURE__*/React.createElement(LabelTag, _extends({
+  return /*#__PURE__*/React__default.createElement(React__default.Fragment, null, label && /*#__PURE__*/React__default.createElement(LabelTag, _extends({
     className: 'input_label'
   }, !isLegend && {
     htmlFor
-  }), label), hint && /*#__PURE__*/React.createElement("p", {
+  }), label), hint && /*#__PURE__*/React__default.createElement("p", {
     id: htmlFor + '-hint',
     className: 'input_hint'
-  }, hint), error && /*#__PURE__*/React.createElement("p", {
+  }, hint), error && /*#__PURE__*/React__default.createElement("p", {
     id: htmlFor + '-error',
     className: 'input_error'
   }, error));
@@ -627,11 +558,6 @@ InputLabel.propTypes = {
   error: PropTypes.string
 };
 
-var InputLabel$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  InputLabel: InputLabel
-});
-
 const Checkboxes = ({
   onChange,
   id,
@@ -644,7 +570,7 @@ const Checkboxes = ({
   children,
   className
 }) => {
-  return /*#__PURE__*/React.createElement("fieldset", _extends({
+  return /*#__PURE__*/React__default.createElement("fieldset", _extends({
     className: classnames(['input', {
       'js-error': error,
       'input-disabled': disabled,
@@ -653,16 +579,16 @@ const Checkboxes = ({
     onChange: onChange
   }, hint || error ? {
     'aria-describedby': [hint ? `${id}-hint` : null, error ? `${id}-error` : null].filter(Boolean).join(' ')
-  } : null), /*#__PURE__*/React.createElement(InputLabel, {
+  } : null), /*#__PURE__*/React__default.createElement(InputLabel, {
     isLegend: true,
     label: label,
     hint: hint,
     error: error
-  }), /*#__PURE__*/React.createElement("div", {
+  }), /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['input_control', 'radios', {
       [`radios-${direction}`]: direction
     }])
-  }, React.Children.map(children, child => /*#__PURE__*/React.isValidElement(child) ? /*#__PURE__*/React.cloneElement(child, {
+  }, React__default.Children.map(children, child => /*#__PURE__*/React__default.isValidElement(child) ? /*#__PURE__*/React__default.cloneElement(child, {
     optional,
     disabled
   }) : child)));
@@ -680,18 +606,13 @@ Checkboxes.propTypes = {
   className: PropTypes.node
 };
 
-var Checkboxes$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Checkboxes: Checkboxes
-});
-
 const Divider = ({
   direction = 'landscape',
   padding = 'md',
   className,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['divider', {
       [`divider-${direction}`]: direction,
       [`divider-${padding}`]: padding
@@ -704,11 +625,6 @@ Divider.propTypes = {
   className: PropTypes.node
 };
 
-var Divider$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Divider: Divider
-});
-
 const Input = ({
   onChange,
   type = 'text',
@@ -730,8 +646,8 @@ const Input = ({
       inputRef.current.focus();
     }
   }, [isFocused]);
-  const customIcon = icon || type === 'date' && /*#__PURE__*/React.createElement(CalendarBlank, null) || type === 'time' && /*#__PURE__*/React.createElement(Clock, null) || type === 'number' && /*#__PURE__*/React.createElement(CaretUpDown, null);
-  return /*#__PURE__*/React.createElement("div", {
+  const customIcon = icon || type === 'date' && /*#__PURE__*/React__default.createElement(CalendarBlank, null) || type === 'time' && /*#__PURE__*/React__default.createElement(Clock, null) || type === 'number' && /*#__PURE__*/React__default.createElement(CaretUpDown, null);
+  return /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['input', {
       'js-error': error,
       'input-disabled': disabled,
@@ -739,14 +655,14 @@ const Input = ({
       'input-withIcon': icon
     }, className]),
     onChange: onChange
-  }, /*#__PURE__*/React.createElement(InputLabel, {
+  }, /*#__PURE__*/React__default.createElement(InputLabel, {
     htmlFor: id,
     label: label,
     hint: hint,
     error: error
-  }), customIcon && /*#__PURE__*/React.createElement("div", {
+  }), customIcon && /*#__PURE__*/React__default.createElement("div", {
     className: 'input_icon'
-  }, customIcon), /*#__PURE__*/React.createElement("input", _extends({
+  }, customIcon), /*#__PURE__*/React__default.createElement("input", _extends({
     ref: inputRef,
     type: type,
     className: 'input_control',
@@ -774,12 +690,7 @@ Input.propTypes = {
   className: PropTypes.node
 };
 
-var Input$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Input: Input
-});
-
-const Link = ({
+const Link$1 = ({
   component = 'a',
   icon,
   color,
@@ -790,20 +701,20 @@ const Link = ({
   ...props
 }) => {
   const Component = component || 'a';
-  return /*#__PURE__*/React.createElement(Component, _extends({
+  return /*#__PURE__*/React__default.createElement(Component, _extends({
     className: classnames(['link', {
       [`text-${color}`]: color
     }, className]),
     href: isExternal ? href : undefined,
     target: isExternal ? '_blank' : undefined,
     rel: isExternal ? 'noopener noreferrer' : undefined
-  }, props), children, icon && !isExternal && /*#__PURE__*/React.createElement("span", {
+  }, props), children, icon && !isExternal && /*#__PURE__*/React__default.createElement("span", {
     className: 'link_icon'
-  }, icon), isExternal && /*#__PURE__*/React.createElement("span", {
+  }, icon), isExternal && /*#__PURE__*/React__default.createElement("span", {
     className: 'link_icon'
-  }, /*#__PURE__*/React.createElement(ArrowSquareOut, null)));
+  }, /*#__PURE__*/React__default.createElement(ArrowSquareOut, null)));
 };
-Link.propTypes = {
+Link$1.propTypes = {
   component: PropTypes.oneOfType(['a', PropTypes.elementType]),
   icon: PropTypes.node,
   color: PropTypes.oneOf(['default', 'alt', 'disabled', 'contrast', 'contrastAlt', 'contrastDisabled', 'primary', 'secondary', 'inherit']),
@@ -812,18 +723,13 @@ Link.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Link$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Link: Link
-});
-
 const List = ({
   dense,
   className,
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['list', {
       'list-dense': dense
     }, className])
@@ -835,11 +741,6 @@ List.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var List$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  List: List
-});
-
 const ListItem = ({
   icon,
   bold,
@@ -847,11 +748,11 @@ const ListItem = ({
   children = 'List item',
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement(Text, _extends({
+  return /*#__PURE__*/React__default.createElement(Text, _extends({
     className: classnames(['list_item', {
       'list_item-bold': bold
     }, className])
-  }, props), icon ? /*#__PURE__*/React.cloneElement(icon, {
+  }, props), icon ? /*#__PURE__*/React__default.cloneElement(icon, {
     className: `${icon.props.className ?? ''} list_itemIcon`
   }) : null, children);
 };
@@ -862,11 +763,6 @@ ListItem.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var ListItem$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  ListItem: ListItem
-});
-
 const Nav = ({
   direction,
   dense,
@@ -874,12 +770,12 @@ const Nav = ({
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("nav", _extends({
+  return /*#__PURE__*/React__default.createElement("nav", _extends({
     className: classnames(['nav', {
       [`nav-${direction}`]: direction,
       'nav-dense': dense
     }, className])
-  }, props), /*#__PURE__*/React.createElement("div", {
+  }, props), /*#__PURE__*/React__default.createElement("div", {
     className: "nav_container"
   }, children));
 };
@@ -890,10 +786,1959 @@ Nav.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Nav$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Nav: Nav
+var dist = {};
+
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  Object.defineProperty(dist, "__esModule", {
+    value: true
+  });
+  dist.parse = parse;
+  dist.serialize = serialize;
+  /**
+   * RegExp to match cookie-name in RFC 6265 sec 4.1.1
+   * This refers out to the obsoleted definition of token in RFC 2616 sec 2.2
+   * which has been replaced by the token definition in RFC 7230 appendix B.
+   *
+   * cookie-name       = token
+   * token             = 1*tchar
+   * tchar             = "!" / "#" / "$" / "%" / "&" / "'" /
+   *                     "*" / "+" / "-" / "." / "^" / "_" /
+   *                     "`" / "|" / "~" / DIGIT / ALPHA
+   *
+   * Note: Allowing more characters - https://github.com/jshttp/cookie/issues/191
+   * Allow same range as cookie value, except `=`, which delimits end of name.
+   */
+  const cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
+  /**
+   * RegExp to match cookie-value in RFC 6265 sec 4.1.1
+   *
+   * cookie-value      = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
+   * cookie-octet      = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
+   *                     ; US-ASCII characters excluding CTLs,
+   *                     ; whitespace DQUOTE, comma, semicolon,
+   *                     ; and backslash
+   *
+   * Allowing more characters: https://github.com/jshttp/cookie/issues/191
+   * Comma, backslash, and DQUOTE are not part of the parsing algorithm.
+   */
+  const cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
+  /**
+   * RegExp to match domain-value in RFC 6265 sec 4.1.1
+   *
+   * domain-value      = <subdomain>
+   *                     ; defined in [RFC1034], Section 3.5, as
+   *                     ; enhanced by [RFC1123], Section 2.1
+   * <subdomain>       = <label> | <subdomain> "." <label>
+   * <label>           = <let-dig> [ [ <ldh-str> ] <let-dig> ]
+   *                     Labels must be 63 characters or less.
+   *                     'let-dig' not 'letter' in the first char, per RFC1123
+   * <ldh-str>         = <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+   * <let-dig-hyp>     = <let-dig> | "-"
+   * <let-dig>         = <letter> | <digit>
+   * <letter>          = any one of the 52 alphabetic characters A through Z in
+   *                     upper case and a through z in lower case
+   * <digit>           = any one of the ten digits 0 through 9
+   *
+   * Keep support for leading dot: https://github.com/jshttp/cookie/issues/173
+   *
+   * > (Note that a leading %x2E ("."), if present, is ignored even though that
+   * character is not permitted, but a trailing %x2E ("."), if present, will
+   * cause the user agent to ignore the attribute.)
+   */
+  const domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+  /**
+   * RegExp to match path-value in RFC 6265 sec 4.1.1
+   *
+   * path-value        = <any CHAR except CTLs or ";">
+   * CHAR              = %x01-7F
+   *                     ; defined in RFC 5234 appendix B.1
+   */
+  const pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
+  const __toString = Object.prototype.toString;
+  const NullObject = /* @__PURE__ */(() => {
+    const C = function () {};
+    C.prototype = Object.create(null);
+    return C;
+  })();
+  /**
+   * Parse a cookie header.
+   *
+   * Parse the given cookie header string into an object
+   * The object has the various cookies as keys(names) => values
+   */
+  function parse(str, options) {
+    const obj = new NullObject();
+    const len = str.length;
+    // RFC 6265 sec 4.1.1, RFC 2616 2.2 defines a cookie name consists of one char minimum, plus '='.
+    if (len < 2) return obj;
+    const dec = options?.decode || decode;
+    let index = 0;
+    do {
+      const eqIdx = str.indexOf("=", index);
+      if (eqIdx === -1) break; // No more cookie pairs.
+      const colonIdx = str.indexOf(";", index);
+      const endIdx = colonIdx === -1 ? len : colonIdx;
+      if (eqIdx > endIdx) {
+        // backtrack on prior semicolon
+        index = str.lastIndexOf(";", eqIdx - 1) + 1;
+        continue;
+      }
+      const keyStartIdx = startIndex(str, index, eqIdx);
+      const keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
+      const key = str.slice(keyStartIdx, keyEndIdx);
+      // only assign once
+      if (obj[key] === undefined) {
+        let valStartIdx = startIndex(str, eqIdx + 1, endIdx);
+        let valEndIdx = endIndex(str, endIdx, valStartIdx);
+        const value = dec(str.slice(valStartIdx, valEndIdx));
+        obj[key] = value;
+      }
+      index = endIdx + 1;
+    } while (index < len);
+    return obj;
+  }
+  function startIndex(str, index, max) {
+    do {
+      const code = str.charCodeAt(index);
+      if (code !== 0x20 /*   */ && code !== 0x09 /* \t */) return index;
+    } while (++index < max);
+    return max;
+  }
+  function endIndex(str, index, min) {
+    while (index > min) {
+      const code = str.charCodeAt(--index);
+      if (code !== 0x20 /*   */ && code !== 0x09 /* \t */) return index + 1;
+    }
+    return min;
+  }
+  /**
+   * Serialize data into a cookie header.
+   *
+   * Serialize a name value pair into a cookie string suitable for
+   * http headers. An optional options object specifies cookie parameters.
+   *
+   * serialize('foo', 'bar', { httpOnly: true })
+   *   => "foo=bar; httpOnly"
+   */
+  function serialize(name, val, options) {
+    const enc = options?.encode || encodeURIComponent;
+    if (!cookieNameRegExp.test(name)) {
+      throw new TypeError(`argument name is invalid: ${name}`);
+    }
+    const value = enc(val);
+    if (!cookieValueRegExp.test(value)) {
+      throw new TypeError(`argument val is invalid: ${val}`);
+    }
+    let str = name + "=" + value;
+    if (!options) return str;
+    if (options.maxAge !== undefined) {
+      if (!Number.isInteger(options.maxAge)) {
+        throw new TypeError(`option maxAge is invalid: ${options.maxAge}`);
+      }
+      str += "; Max-Age=" + options.maxAge;
+    }
+    if (options.domain) {
+      if (!domainValueRegExp.test(options.domain)) {
+        throw new TypeError(`option domain is invalid: ${options.domain}`);
+      }
+      str += "; Domain=" + options.domain;
+    }
+    if (options.path) {
+      if (!pathValueRegExp.test(options.path)) {
+        throw new TypeError(`option path is invalid: ${options.path}`);
+      }
+      str += "; Path=" + options.path;
+    }
+    if (options.expires) {
+      if (!isDate(options.expires) || !Number.isFinite(options.expires.valueOf())) {
+        throw new TypeError(`option expires is invalid: ${options.expires}`);
+      }
+      str += "; Expires=" + options.expires.toUTCString();
+    }
+    if (options.httpOnly) {
+      str += "; HttpOnly";
+    }
+    if (options.secure) {
+      str += "; Secure";
+    }
+    if (options.partitioned) {
+      str += "; Partitioned";
+    }
+    if (options.priority) {
+      const priority = typeof options.priority === "string" ? options.priority.toLowerCase() : undefined;
+      switch (priority) {
+        case "low":
+          str += "; Priority=Low";
+          break;
+        case "medium":
+          str += "; Priority=Medium";
+          break;
+        case "high":
+          str += "; Priority=High";
+          break;
+        default:
+          throw new TypeError(`option priority is invalid: ${options.priority}`);
+      }
+    }
+    if (options.sameSite) {
+      const sameSite = typeof options.sameSite === "string" ? options.sameSite.toLowerCase() : options.sameSite;
+      switch (sameSite) {
+        case true:
+        case "strict":
+          str += "; SameSite=Strict";
+          break;
+        case "lax":
+          str += "; SameSite=Lax";
+          break;
+        case "none":
+          str += "; SameSite=None";
+          break;
+        default:
+          throw new TypeError(`option sameSite is invalid: ${options.sameSite}`);
+      }
+    }
+    return str;
+  }
+  /**
+   * URL-decode string value. Optimized to skip native call when no %.
+   */
+  function decode(str) {
+    if (str.indexOf("%") === -1) return str;
+    try {
+      return decodeURIComponent(str);
+    } catch (e) {
+      return str;
+    }
+  }
+  /**
+   * Determine if value is a Date.
+   */
+  function isDate(val) {
+    return __toString.call(val) === "[object Date]";
+  }
+  return dist;
+}
+
+requireDist();
+
+/**
+ * react-router v7.3.0
+ *
+ * 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 = "") {
+  let flattenRoute = (route, index, relativePath) => {
+    let meta = {
+      relativePath: relativePath === void 0 ? route.path || "" : relativePath,
+      caseSensitive: route.caseSensitive === true,
+      childrenIndex: index,
+      route
+    };
+    if (meta.relativePath.startsWith("/")) {
+      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);
+    }
+    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, 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 ? "/?([^\\/]+)?" : "/([^\\/]+)";
+    }
+  );
+  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 = React.createContext(null);
+DataRouterContext.displayName = "DataRouter";
+var DataRouterStateContext = React.createContext(null);
+DataRouterStateContext.displayName = "DataRouterState";
+var ViewTransitionContext = React.createContext({
+  isTransitioning: false
+});
+ViewTransitionContext.displayName = "ViewTransition";
+var FetchersContext = React.createContext(
+  /* @__PURE__ */ new Map()
+);
+FetchersContext.displayName = "Fetchers";
+var AwaitContext = React.createContext(null);
+AwaitContext.displayName = "Await";
+var NavigationContext = React.createContext(
+  null
+);
+NavigationContext.displayName = "Navigation";
+var LocationContext = React.createContext(
+  null
+);
+LocationContext.displayName = "Location";
+var RouteContext = React.createContext({
+  outlet: null,
+  matches: [],
+  isDataRoute: false
 });
+RouteContext.displayName = "Route";
+var RouteErrorContext = React.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: navigator2 } = React.useContext(NavigationContext);
+  let { hash, pathname, search } = useResolvedPath(to, { relative });
+  let joinedPathname = pathname;
+  if (basename !== "/") {
+    joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
+  }
+  return navigator2.createHref({ pathname: joinedPathname, search, hash });
+}
+function useInRouterContext() {
+  return React.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 React.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 = React.useContext(NavigationContext).static;
+  if (!isStatic) {
+    React.useLayoutEffect(cb);
+  }
+}
+function useNavigate() {
+  let { isDataRoute } = React.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 = React.useContext(DataRouterContext);
+  let { basename, navigator: navigator2 } = React.useContext(NavigationContext);
+  let { matches } = React.useContext(RouteContext);
+  let { pathname: locationPathname } = useLocation();
+  let routePathnamesJson = JSON.stringify(getResolveToMatches(matches));
+  let activeRef = React.useRef(false);
+  useIsomorphicLayoutEffect(() => {
+    activeRef.current = true;
+  });
+  let navigate = React.useCallback(
+    (to, options = {}) => {
+      warning(activeRef.current, navigateEffectWarning);
+      if (!activeRef.current) return;
+      if (typeof to === "number") {
+        navigator2.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 ? navigator2.replace : navigator2.push)(
+        path,
+        options.state,
+        options
+      );
+    },
+    [
+      basename,
+      navigator2,
+      routePathnamesJson,
+      locationPathname,
+      dataRouterContext
+    ]
+  );
+  return navigate;
+}
+React.createContext(null);
+function useResolvedPath(to, { relative } = {}) {
+  let { matches } = React.useContext(RouteContext);
+  let { pathname: locationPathname } = useLocation();
+  let routePathnamesJson = JSON.stringify(getResolveToMatches(matches));
+  return React.useMemo(
+    () => resolveTo(
+      to,
+      JSON.parse(routePathnamesJson),
+      locationPathname,
+      relative === "path"
+    ),
+    [to, routePathnamesJson, locationPathname, relative]
+  );
+}
+function useRoutesImpl(routes, locationArg, dataRouterState, 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: navigator2, static: isStatic } = React.useContext(NavigationContext);
+  let { matches: parentMatches } = React.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 = !isStatic && dataRouterState && dataRouterState.matches && dataRouterState.matches.length > 0 ? dataRouterState.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
+          navigator2.encodeLocation ? navigator2.encodeLocation(match.pathname).pathname : match.pathname
+        ]),
+        pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([
+          parentPathnameBase,
+          // Re-encode pathnames that were decoded inside matchRoutes
+          navigator2.encodeLocation ? navigator2.encodeLocation(match.pathnameBase).pathname : match.pathnameBase
+        ])
+      })
+    ),
+    parentMatches,
+    dataRouterState,
+    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__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("p", null, "\u{1F4BF} Hey developer \u{1F44B}"), /* @__PURE__ */ React.createElement("p", null, "You can provide a way better UX than this when your app throws errors by providing your own ", /* @__PURE__ */ React.createElement("code", { style: codeStyles }, "ErrorBoundary"), " or", " ", /* @__PURE__ */ React.createElement("code", { style: codeStyles }, "errorElement"), " prop on your route."));
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("h2", null, "Unexpected Application Error!"), /* @__PURE__ */ React.createElement("h3", { style: { fontStyle: "italic" } }, message), stack ? /* @__PURE__ */ React.createElement("pre", { style: preStyles }, stack) : null, devInfo);
+}
+var defaultErrorElement = /* @__PURE__ */ React.createElement(DefaultErrorComponent, null);
+var RenderErrorBoundary = class extends React.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) {
+    console.error(
+      "React Router caught the following error during render",
+      error,
+      errorInfo
+    );
+  }
+  render() {
+    return this.state.error !== void 0 ? /* @__PURE__ */ React.createElement(RouteContext.Provider, { value: this.props.routeContext }, /* @__PURE__ */ React.createElement(
+      RouteErrorContext.Provider,
+      {
+        value: this.state.error,
+        children: this.props.component
+      }
+    )) : this.props.children;
+  }
+};
+function RenderedRoute({ routeContext, match, children }) {
+  let dataRouterContext = React.useContext(DataRouterContext);
+  if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {
+    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;
+  }
+  return /* @__PURE__ */ React.createElement(RouteContext.Provider, { value: routeContext }, children);
+}
+function _renderMatches(matches, parentMatches = [], dataRouterState = 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__ */ React.createElement(match.route.Component, null);
+      } else if (match.route.element) {
+        children = match.route.element;
+      } else {
+        children = outlet;
+      }
+      return /* @__PURE__ */ React.createElement(
+        RenderedRoute,
+        {
+          match,
+          routeContext: {
+            outlet,
+            matches: matches2,
+            isDataRoute: dataRouterState != null
+          },
+          children
+        }
+      );
+    };
+    return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /* @__PURE__ */ React.createElement(
+      RenderErrorBoundary,
+      {
+        location: dataRouterState.location,
+        revalidation: dataRouterState.revalidation,
+        component: errorElement,
+        error,
+        children: getChildren(),
+        routeContext: { outlet: null, matches: matches2, isDataRoute: true }
+      }
+    ) : 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 = React.useContext(DataRouterContext);
+  invariant(ctx, getDataRouterConsoleError(hookName));
+  return ctx;
+}
+function useDataRouterState(hookName) {
+  let state = React.useContext(DataRouterStateContext);
+  invariant(state, getDataRouterConsoleError(hookName));
+  return state;
+}
+function useRouteContext(hookName) {
+  let route = React.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 = React.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 = React.useRef(false);
+  useIsomorphicLayoutEffect(() => {
+    activeRef.current = true;
+  });
+  let navigate = React.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);
+  }
+}
+React.memo(DataRoutes);
+function DataRoutes({
+  routes,
+  future,
+  state
+}) {
+  return useRoutesImpl(routes, void 0, state, 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 };
+}
+
+// lib/dom/ssr/invariant.ts
+function invariant2(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    throw new Error(message);
+  }
+}
+
+// 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;
+  }, []);
+}
+function singleFetchUrl(reqUrl, basename) {
+  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.data";
+  } else if (basename && stripBasename(url.pathname, basename) === "/") {
+    url.pathname = `${basename.replace(/\/$/, "")}/_root.data`;
+  } else {
+    url.pathname = `${url.pathname.replace(/\/$/, "")}.data`;
+  }
+  return url;
+}
+
+// lib/dom/ssr/components.tsx
+function useDataRouterContext2() {
+  let context = React.useContext(DataRouterContext);
+  invariant2(
+    context,
+    "You must render this element inside a <DataRouterContext.Provider> element"
+  );
+  return context;
+}
+function useDataRouterStateContext() {
+  let context = React.useContext(DataRouterStateContext);
+  invariant2(
+    context,
+    "You must render this element inside a <DataRouterStateContext.Provider> element"
+  );
+  return context;
+}
+var FrameworkContext = React.createContext(void 0);
+FrameworkContext.displayName = "FrameworkContext";
+function useFrameworkContext() {
+  let context = React.useContext(FrameworkContext);
+  invariant2(
+    context,
+    "You must render this element inside a <HydratedRouter> element"
+  );
+  return context;
+}
+function usePrefetchBehavior(prefetch, theirElementProps) {
+  let frameworkContext = React.useContext(FrameworkContext);
+  let [maybePrefetch, setMaybePrefetch] = React.useState(false);
+  let [shouldPrefetch, setShouldPrefetch] = React.useState(false);
+  let { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
+  let ref = React.useRef(null);
+  React.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]);
+  React.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,
+  ...dataLinkProps
+}) {
+  let { router } = useDataRouterContext2();
+  let matches = React.useMemo(
+    () => matchRoutes(router.routes, page, router.basename),
+    [router.routes, page, router.basename]
+  );
+  if (!matches) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(PrefetchPageLinksImpl, { page, matches, ...dataLinkProps });
+}
+function useKeyedPrefetchLinks(matches) {
+  let { manifest, routeModules } = useFrameworkContext();
+  let [keyedPrefetchLinks, setKeyedPrefetchLinks] = React.useState([]);
+  React.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 = React.useMemo(
+    () => getNewMatchesForLinks(
+      page,
+      nextMatches,
+      matches,
+      manifest,
+      location,
+      "data"
+    ),
+    [page, nextMatches, matches, manifest, location]
+  );
+  let newMatchesForAssets = React.useMemo(
+    () => getNewMatchesForLinks(
+      page,
+      nextMatches,
+      matches,
+      manifest,
+      location,
+      "assets"
+    ),
+    [page, nextMatches, matches, manifest, location]
+  );
+  let dataHrefs = React.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);
+    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 = React.useMemo(
+    () => getModuleLinkHrefs(newMatchesForAssets, manifest),
+    [newMatchesForAssets, manifest]
+  );
+  let keyedPrefetchLinks = useKeyedPrefetchLinks(newMatchesForAssets);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, dataHrefs.map((href2) => /* @__PURE__ */ React.createElement("link", { key: href2, rel: "prefetch", as: "fetch", href: href2, ...linkProps })), moduleHrefs.map((href2) => /* @__PURE__ */ React.createElement("link", { key: href2, rel: "modulepreload", href: href2, ...linkProps })), keyedPrefetchLinks.map(({ key, link }) => (
+    // these don't spread `linkProps` because they are full link descriptors
+    // already with their own props
+    /* @__PURE__ */ React.createElement("link", { key, ...link })
+  )));
+}
+function mergeRefs(...refs) {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        ref.current = value;
+      }
+    });
+  };
+}
+
+// lib/dom/lib.tsx
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+try {
+  if (isBrowser) {
+    window.__reactRouterVersion = "7.3.0";
+  }
+} catch (e) {
+}
+var ABSOLUTE_URL_REGEX2 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+var Link = React.forwardRef(
+  function LinkWithRef({
+    onClick,
+    discover = "render",
+    prefetch = "none",
+    relative,
+    reloadDocument,
+    replace: replace2,
+    state,
+    target,
+    to,
+    preventScrollReset,
+    viewTransition,
+    ...rest
+  }, forwardedRef) {
+    let { basename } = React.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 href2 = 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__ */ React.createElement(
+        "a",
+        {
+          ...rest,
+          ...prefetchHandlers,
+          href: absoluteHref || href2,
+          onClick: isExternal || reloadDocument ? onClick : handleClick,
+          ref: mergeRefs(forwardedRef, prefetchRef),
+          target,
+          "data-discover": !isAbsolute && discover === "render" ? "true" : void 0
+        }
+      )
+    );
+    return shouldPrefetch && !isAbsolute ? /* @__PURE__ */ React.createElement(React.Fragment, null, link, /* @__PURE__ */ React.createElement(PrefetchPageLinks, { page: href2 })) : link;
+  }
+);
+Link.displayName = "Link";
+var NavLink = React.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 = React.useContext(DataRouterStateContext);
+    let { navigator: navigator2, basename } = React.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 = navigator2.encodeLocation ? navigator2.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__ */ React.createElement(
+      Link,
+      {
+        ...rest,
+        "aria-current": ariaCurrent,
+        className,
+        ref,
+        style,
+        to,
+        viewTransition
+      },
+      typeof children === "function" ? children(renderProps) : children
+    );
+  }
+);
+NavLink.displayName = "NavLink";
+var Form = React.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__ */ React.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 = React.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 React.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 } = React.useContext(NavigationContext);
+  let currentRouteId = useRouteId();
+  return React.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 } = React.useContext(NavigationContext);
+  let routeContext = React.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, opts = {}) {
+  let vtContext = React.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: 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;
+  return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;
+}
+
+// lib/server-runtime/crypto.ts
+new TextEncoder();
 
 const SectionHeader = ({
   label,
@@ -905,16 +2750,16 @@ const SectionHeader = ({
   className,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['section_header', className])
-  }, props), label ? /*#__PURE__*/React.createElement(Text, {
+  }, props), label ? /*#__PURE__*/React__default.createElement(Text, {
     className: classnames('section_label')
-  }, label) : null, /*#__PURE__*/React.createElement(Text, {
+  }, label) : null, /*#__PURE__*/React__default.createElement(Text, {
     className: "section_title",
     component: titleComponent || (promoteTitle ? 'h1' : 'h2')
-  }, title), subtitle ? /*#__PURE__*/React.createElement(Text, {
+  }, title), subtitle ? /*#__PURE__*/React__default.createElement(Text, {
     className: classnames('section_subtitle')
-  }, subtitle) : null, actions ? /*#__PURE__*/React.createElement("div", {
+  }, subtitle) : null, actions ? /*#__PURE__*/React__default.createElement("div", {
     className: "section_actions"
   }, actions) : null);
 };
@@ -928,11 +2773,6 @@ SectionHeader.propTypes = {
   className: PropTypes.node
 };
 
-var SectionHeader$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  SectionHeader: SectionHeader
-});
-
 const Section = ({
   align = 'left',
   color = 'default',
@@ -942,18 +2782,18 @@ const Section = ({
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['section', {
       [`section-${align}`]: align,
       [`section-${color}`]: color,
       'section-landing': landing,
       'section-header': header
     }, className])
-  }, props), /*#__PURE__*/React.createElement("div", {
+  }, props), /*#__PURE__*/React__default.createElement("div", {
     className: 'section_container'
-  }, React.Children.map(children, child => {
-    if (/*#__PURE__*/React.isValidElement(child) && child.type === SectionHeader) {
-      return /*#__PURE__*/React.cloneElement(child, {
+  }, React__default.Children.map(children, child => {
+    if (/*#__PURE__*/React__default.isValidElement(child) && child.type === SectionHeader) {
+      return /*#__PURE__*/React__default.cloneElement(child, {
         promoteTitle: landing || header
       });
     }
@@ -969,13 +2809,8 @@ Section.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Section$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Section: Section
-});
-
 const NavBar = ({
-  logo,
+  homeLinkComponent,
   align,
   className,
   children,
@@ -986,42 +2821,42 @@ const NavBar = ({
     setIsOpen(!isOpen);
     document.body.classList.toggle('js-navbar', !isOpen);
   };
-  return /*#__PURE__*/React.createElement("header", null, /*#__PURE__*/React.createElement(Section, _extends({
+  const HomeLinkComponent = homeLinkComponent || Link;
+  return /*#__PURE__*/React__default.createElement("header", null, /*#__PURE__*/React__default.createElement(Section, _extends({
     className: classnames(['navbar', {
       [`navbar-${align}`]: align,
       'js-opened': isOpen
     }, className])
-  }, props), /*#__PURE__*/React.createElement("div", {
+  }, props), /*#__PURE__*/React__default.createElement("div", {
     className: "navbar_main"
-  }, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/React__default.createElement(HomeLinkComponent, {
+    to: "/",
+    exact: true,
     className: "navbar_logo"
-  }, logo), /*#__PURE__*/React.createElement("button", {
+  }, /*#__PURE__*/React__default.createElement("img", {
+    src: "https://pallote.com/logos/pallote-logo.svg",
+    alt: "Logo for Pallote"
+  })), /*#__PURE__*/React__default.createElement("button", {
     "aria-label": "Open mobile menu",
     className: classnames('navbar_button', {
       'js-opened': isOpen
     }),
     onClick: toggleNav
-  }, /*#__PURE__*/React.createElement("span", null))), /*#__PURE__*/React.createElement("nav", {
+  }, /*#__PURE__*/React__default.createElement("span", null))), /*#__PURE__*/React__default.createElement("nav", {
     "aria-label": "main-nav",
     className: classnames('navbar_nav nav', {
       'js-opened': isOpen
     })
-  }, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/React__default.createElement("div", {
     className: "nav_container"
   }, children))));
 };
 NavBar.propTypes = {
-  logo: PropTypes.node,
   align: PropTypes.oneOf(['left', 'right']),
   className: PropTypes.node,
   children: PropTypes.node.isRequired
 };
 
-var NavBar$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  NavBar: NavBar
-});
-
 const NavItem = ({
   component,
   label,
@@ -1040,23 +2875,23 @@ const NavItem = ({
   if (dropdown) {
     Component = 'button';
   } else {
-    Component = component || "a";
+    Component = component || Link;
   }
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['nav_item', {
       'nav_item-dropdown': dropdown,
       'js-show': isExpanded
     }, className])
-  }, /*#__PURE__*/React.createElement(Component, _extends({
+  }, /*#__PURE__*/React__default.createElement(Component, _extends({
     end: end,
     to: to,
     className: classnames(['nav_trigger', {
       'nav_trigger-active': active
     }]),
     onClick: onClick
-  }, props), icon ? /*#__PURE__*/React.createElement("span", {
+  }, props), icon ? /*#__PURE__*/React__default.createElement("span", {
     className: classnames('nav_icon')
-  }, icon) : null, label), dropdown ? /*#__PURE__*/React.createElement("div", {
+  }, icon) : null, label), dropdown ? /*#__PURE__*/React__default.createElement("div", {
     ref: dropdownRef,
     className: "nav_target"
   }, dropdown) : null);
@@ -1071,11 +2906,6 @@ NavItem.propTypes = {
   className: PropTypes.node
 };
 
-var NavItem$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  NavItem: NavItem
-});
-
 const Radio = ({
   id,
   name,
@@ -1087,11 +2917,11 @@ const Radio = ({
   className,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['radio', {
       'radio-disabled': disabled
     }, className])
-  }, /*#__PURE__*/React.createElement("input", _extends({
+  }, /*#__PURE__*/React__default.createElement("input", _extends({
     className: classnames('radio_control'),
     type: "radio",
     id: id,
@@ -1101,7 +2931,7 @@ const Radio = ({
     "aria-checked": checked,
     disabled: disabled,
     required: !(disabled || optional)
-  }, props)), /*#__PURE__*/React.createElement("label", {
+  }, props)), /*#__PURE__*/React__default.createElement("label", {
     className: classnames('radio_label'),
     htmlFor: id
   }, label));
@@ -1117,11 +2947,6 @@ Radio.propTypes = {
   className: PropTypes.node
 };
 
-var Radio$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Radio: Radio
-});
-
 const RadioButtons = ({
   onChange,
   id,
@@ -1134,7 +2959,7 @@ const RadioButtons = ({
   children,
   className
 }) => {
-  return /*#__PURE__*/React.createElement("fieldset", _extends({
+  return /*#__PURE__*/React__default.createElement("fieldset", _extends({
     className: classnames(['input', {
       'js-error': error,
       'input-disabled': disabled,
@@ -1143,16 +2968,16 @@ const RadioButtons = ({
     onChange: onChange
   }, hint || error ? {
     'aria-describedby': [hint ? `${id}-hint` : null, error ? `${id}-error` : null].filter(Boolean).join(' ')
-  } : null), /*#__PURE__*/React.createElement(InputLabel, {
+  } : null), /*#__PURE__*/React__default.createElement(InputLabel, {
     isLegend: true,
     label: label,
     hint: hint,
     error: error
-  }), /*#__PURE__*/React.createElement("div", {
+  }), /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['input_control', 'radios', {
       [`radios-${direction}`]: direction
     }])
-  }, React.Children.map(children, child => /*#__PURE__*/React.isValidElement(child) ? /*#__PURE__*/React.cloneElement(child, {
+  }, React__default.Children.map(children, child => /*#__PURE__*/React__default.isValidElement(child) ? /*#__PURE__*/React__default.cloneElement(child, {
     optional,
     disabled
   }) : child)));
@@ -1170,18 +2995,13 @@ RadioButtons.propTypes = {
   className: PropTypes.node
 };
 
-var RadioButtons$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  RadioButtons: RadioButtons
-});
-
 const SectionContent = ({
   align = 'left',
   className,
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['section_content', {
       [`section_content-${align}`]: align
     }, className])
@@ -1193,11 +3013,6 @@ SectionContent.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var SectionContent$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  SectionContent: SectionContent
-});
-
 const Select = ({
   onChange,
   id,
@@ -1218,7 +3033,7 @@ const Select = ({
       inputRef.current.focus();
     }
   }, [isFocused]);
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['input', 'select', {
       'input-focused': isFocused,
       'js-error': error,
@@ -1227,12 +3042,12 @@ const Select = ({
       'input-dense': dense
     }, className]),
     onChange: onChange
-  }, /*#__PURE__*/React.createElement(InputLabel, {
+  }, /*#__PURE__*/React__default.createElement(InputLabel, {
     htmlFor: id,
     label: label,
     hint: hint,
     error: error
-  }), /*#__PURE__*/React.createElement("select", _extends({
+  }), /*#__PURE__*/React__default.createElement("select", _extends({
     ref: inputRef,
     className: 'input_control',
     name: id,
@@ -1257,11 +3072,6 @@ Select.propTypes = {
   className: PropTypes.node
 };
 
-var Select$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Select: Select
-});
-
 var nnfxDark = {
   "hljs": {
     "display": "block",
@@ -1386,9 +3196,9 @@ const Snippet = ({
   className,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React__default.createElement("div", {
     className: classnames('snippet_wrapper')
-  }, /*#__PURE__*/React.createElement(SyntaxHighlighter, _extends({
+  }, /*#__PURE__*/React__default.createElement(SyntaxHighlighter, _extends({
     language: "javascript",
     style: nnfxDark,
     className: classnames(['snippet', {
@@ -1405,11 +3215,6 @@ Snippet.propTypes = {
   className: PropTypes.node
 };
 
-var Snippet$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Snippet: Snippet
-});
-
 const Status = ({
   color = 'inactive',
   dense,
@@ -1417,7 +3222,7 @@ const Status = ({
   children = 'Status',
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement(Text, _extends({
+  return /*#__PURE__*/React__default.createElement(Text, _extends({
     className: classnames(['status', {
       [`status-${color}`]: color,
       'status-dense': dense
@@ -1431,11 +3236,6 @@ Status.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Status$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Status: Status
-});
-
 const Switch = ({
   id,
   startLabel,
@@ -1444,25 +3244,25 @@ const Switch = ({
   className,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['switch', {
       'switch-disabled': disabled
     }, className])
-  }, startLabel ? /*#__PURE__*/React.createElement(Text, {
+  }, startLabel ? /*#__PURE__*/React__default.createElement(Text, {
     className: classnames('switch_label'),
     variant: "body"
-  }, startLabel) : null, /*#__PURE__*/React.createElement("input", _extends({
+  }, startLabel) : null, /*#__PURE__*/React__default.createElement("input", _extends({
     className: classnames('switch_input'),
     type: "checkbox",
     name: id,
     id: id,
     disabled: disabled
-  }, props)), /*#__PURE__*/React.createElement("label", {
+  }, props)), /*#__PURE__*/React__default.createElement("label", {
     className: classnames('switch_switch'),
     htmlFor: id
-  }, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/React__default.createElement("div", {
     className: classnames('switch_toggle')
-  })), endLabel ? /*#__PURE__*/React.createElement(Text, {
+  })), endLabel ? /*#__PURE__*/React__default.createElement(Text, {
     className: classnames('switch_label'),
     variant: "body"
   }, endLabel) : null);
@@ -1475,11 +3275,6 @@ Switch.propTypes = {
   className: PropTypes.node
 };
 
-var Switch$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Switch: Switch
-});
-
 const TabsContext = /*#__PURE__*/createContext();
 const Tabs = ({
   direction,
@@ -1489,12 +3284,12 @@ const Tabs = ({
   children
 }) => {
   const [activeIndex, setActiveIndex] = useState(0);
-  return /*#__PURE__*/React.createElement(TabsContext.Provider, {
+  return /*#__PURE__*/React__default.createElement(TabsContext.Provider, {
     value: {
       activeIndex,
       setActiveIndex
     }
-  }, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['tabs', {
       [`tabs-${direction}`]: direction,
       'tabs-dense': dense,
@@ -1510,12 +3305,6 @@ Tabs.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Tabs$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Tabs: Tabs,
-  TabsContext: TabsContext
-});
-
 const Tab = ({
   index,
   label,
@@ -1526,7 +3315,7 @@ const Tab = ({
     setActiveIndex
   } = useContext(TabsContext);
   const isSelected = activeIndex === index;
-  return /*#__PURE__*/React.createElement("button", {
+  return /*#__PURE__*/React__default.createElement("button", {
     className: classnames(['tab', {
       'tab-active': isSelected
     }, className]),
@@ -1543,79 +3332,69 @@ Tab.propTypes = {
   className: PropTypes.node.isRequired
 };
 
-var Tab$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Tab: Tab
-});
-
 const TableFooter = ({
   className,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("div", _extends({
+  return /*#__PURE__*/React__default.createElement("div", _extends({
     className: classnames(['table_footer', className])
-  }, props), /*#__PURE__*/React.createElement(Select, {
+  }, props), /*#__PURE__*/React__default.createElement(Select, {
     dense: true,
     id: "rows",
     className: "table_rowSelect"
-  }, /*#__PURE__*/React.createElement("option", {
+  }, /*#__PURE__*/React__default.createElement("option", {
     value: "1"
-  }, "10"), /*#__PURE__*/React.createElement("option", {
+  }, "10"), /*#__PURE__*/React__default.createElement("option", {
     value: "2"
-  }, "25"), /*#__PURE__*/React.createElement("option", {
+  }, "25"), /*#__PURE__*/React__default.createElement("option", {
     value: "2"
-  }, "50"), /*#__PURE__*/React.createElement("option", {
+  }, "50"), /*#__PURE__*/React__default.createElement("option", {
     value: "2"
-  }, "100"), /*#__PURE__*/React.createElement("option", {
+  }, "100"), /*#__PURE__*/React__default.createElement("option", {
     value: "2"
-  }, "All")), /*#__PURE__*/React.createElement(Buttons, {
+  }, "All")), /*#__PURE__*/React__default.createElement(Buttons, {
     className: "table_pagination"
-  }, /*#__PURE__*/React.createElement(Button, {
+  }, /*#__PURE__*/React__default.createElement(Button, {
     kind: "icon",
     variant: "transparent",
     size: "sm"
-  }, /*#__PURE__*/React.createElement(CaretDoubleLeft, null)), /*#__PURE__*/React.createElement(Button, {
+  }, /*#__PURE__*/React__default.createElement(CaretDoubleLeft, null)), /*#__PURE__*/React__default.createElement(Button, {
     kind: "icon",
     variant: "transparent",
     size: "sm"
-  }, /*#__PURE__*/React.createElement(CaretLeft, null)), /*#__PURE__*/React.createElement(Button, {
+  }, /*#__PURE__*/React__default.createElement(CaretLeft, null)), /*#__PURE__*/React__default.createElement(Button, {
     kind: "icon",
     size: "sm"
-  }, "1"), /*#__PURE__*/React.createElement(Button, {
+  }, "1"), /*#__PURE__*/React__default.createElement(Button, {
     kind: "icon",
     variant: "transparent",
     size: "sm"
-  }, "2"), /*#__PURE__*/React.createElement(Button, {
+  }, "2"), /*#__PURE__*/React__default.createElement(Button, {
     kind: "icon",
     variant: "transparent",
     size: "sm"
-  }, "3"), /*#__PURE__*/React.createElement(Button, {
+  }, "3"), /*#__PURE__*/React__default.createElement(Button, {
     kind: "icon",
     variant: "transparent",
     size: "sm"
-  }, "\u2026"), /*#__PURE__*/React.createElement(Button, {
+  }, "\u2026"), /*#__PURE__*/React__default.createElement(Button, {
     kind: "icon",
     variant: "transparent",
     size: "sm"
-  }, "8"), /*#__PURE__*/React.createElement(Button, {
+  }, "8"), /*#__PURE__*/React__default.createElement(Button, {
     kind: "icon",
     variant: "transparent",
     size: "sm"
-  }, /*#__PURE__*/React.createElement(CaretRight, null)), /*#__PURE__*/React.createElement(Button, {
+  }, /*#__PURE__*/React__default.createElement(CaretRight, null)), /*#__PURE__*/React__default.createElement(Button, {
     kind: "icon",
     variant: "transparent",
     size: "sm"
-  }, /*#__PURE__*/React.createElement(CaretDoubleRight, null))));
+  }, /*#__PURE__*/React__default.createElement(CaretDoubleRight, null))));
 };
 TableFooter.propTypes = {
   className: PropTypes.node
 };
 
-var TableFooter$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  TableFooter: TableFooter
-});
-
 const DenseContext = /*#__PURE__*/createContext(false);
 const Table = ({
   striped,
@@ -1627,20 +3406,20 @@ const Table = ({
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement(DenseContext.Provider, {
+  return /*#__PURE__*/React__default.createElement(DenseContext.Provider, {
     value: dense
-  }, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['table', {
       'table-striped': striped,
       'table-hasHover': hasHover,
       'table-dense': dense,
       'table-border': border
     }, className])
-  }, /*#__PURE__*/React.createElement("table", _extends({
+  }, /*#__PURE__*/React__default.createElement("table", _extends({
     cellPadding: 0,
     cellSpacing: 0,
     className: classnames('table_content')
-  }, props), children), withFooter ? /*#__PURE__*/React.createElement(TableFooter, {
+  }, props), children), withFooter ? /*#__PURE__*/React__default.createElement(TableFooter, {
     dense: dense ? dense : null
   }) : null));
 };
@@ -1654,18 +3433,12 @@ Table.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Table$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  DenseContext: DenseContext,
-  Table: Table
-});
-
 const TableBody = ({
   className,
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("tbody", _extends({
+  return /*#__PURE__*/React__default.createElement("tbody", _extends({
     className: classnames(['table_body', className])
   }, props), children);
 };
@@ -1674,20 +3447,15 @@ TableBody.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var TableBody$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  TableBody: TableBody
-});
-
 const TableCellComponentContext = /*#__PURE__*/createContext('td');
 const TableHead = ({
   className,
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement(TableCellComponentContext.Provider, {
+  return /*#__PURE__*/React__default.createElement(TableCellComponentContext.Provider, {
     value: "th"
-  }, /*#__PURE__*/React.createElement("thead", _extends({
+  }, /*#__PURE__*/React__default.createElement("thead", _extends({
     className: classnames(['table_head', className])
   }, props), children));
 };
@@ -1696,12 +3464,6 @@ TableHead.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var TableHead$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  TableCellComponentContext: TableCellComponentContext,
-  TableHead: TableHead
-});
-
 const TableCell = ({
   kind = 'default',
   className,
@@ -1710,7 +3472,7 @@ const TableCell = ({
 }) => {
   const useTableCellComponent = () => useContext(TableCellComponentContext);
   const Component = useTableCellComponent();
-  return /*#__PURE__*/React.createElement(Component, _extends({
+  return /*#__PURE__*/React__default.createElement(Component, _extends({
     className: classnames(['table_cell', {
       [`table_cell-${kind}`]: kind
     }, className])
@@ -1722,17 +3484,12 @@ TableCell.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var TableCell$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  TableCell: TableCell
-});
-
 const TableRow = ({
   className,
   children,
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement("tr", _extends({
+  return /*#__PURE__*/React__default.createElement("tr", _extends({
     className: classnames(['table_row', className])
   }, props), children);
 };
@@ -1741,16 +3498,11 @@ TableRow.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var TableRow$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  TableRow: TableRow
-});
-
 const TabsControl = ({
   className,
   children
 }) => {
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React__default.createElement("div", {
     role: "tablist",
     className: classnames(['tabs_controls', className])
   }, children);
@@ -1760,11 +3512,6 @@ TabsControl.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var TabsControl$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  TabsControl: TabsControl
-});
-
 const TabsPanel = ({
   index,
   className,
@@ -1774,7 +3521,7 @@ const TabsPanel = ({
     activeIndex
   } = useContext(TabsContext);
   const isActive = activeIndex === index;
-  return isActive ? /*#__PURE__*/React.createElement("div", {
+  return isActive ? /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['tabs_panel', className]),
     role: "tabpanel",
     id: `tabpanel-${index}`,
@@ -1787,11 +3534,6 @@ TabsPanel.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var TabsPanel$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  TabsPanel: TabsPanel
-});
-
 const Tag = ({
   color = 'primary',
   dense,
@@ -1799,7 +3541,7 @@ const Tag = ({
   children = 'Tag',
   ...props
 }) => {
-  return /*#__PURE__*/React.createElement(Text, _extends({
+  return /*#__PURE__*/React__default.createElement(Text, _extends({
     className: classnames(['tag', {
       [`tag-${color}`]: color,
       'tag-dense': dense
@@ -1813,11 +3555,6 @@ Tag.propTypes = {
   children: PropTypes.node.isRequired
 };
 
-var Tag$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Tag: Tag
-});
-
 const Textarea = ({
   onChange,
   id,
@@ -1837,19 +3574,19 @@ const Textarea = ({
       inputRef.current.focus();
     }
   }, [isFocused]);
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React__default.createElement("div", {
     className: classnames(['input', {
       'js-error': error,
       'input-disabled': disabled,
       'input-optional': optional
     }, className]),
     onChange: onChange
-  }, /*#__PURE__*/React.createElement(InputLabel, {
+  }, /*#__PURE__*/React__default.createElement(InputLabel, {
     htmlFor: id,
     label: label,
     hint: hint,
     error: error
-  }), /*#__PURE__*/React.createElement("textarea", _extends({
+  }), /*#__PURE__*/React__default.createElement("textarea", _extends({
     ref: inputRef,
     className: 'input_control',
     name: id,
@@ -1875,9 +3612,4 @@ Textarea.propTypes = {
   className: PropTypes.node
 };
 
-var Textarea$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Textarea: Textarea
-});
-
-export { Alert$1 as Alert, Breadcrumbs$1 as Breadcrumbs, Button$1 as Button, Buttons$1 as Buttons, Card$1 as Card, CardActions$1 as CardActions, CardContent$1 as CardContent, CardHeader$1 as CardHeader, CardMedia$1 as CardMedia, Checkbox$1 as Checkbox, Checkboxes$1 as Checkboxes, Color$1 as Color, Display$1 as Display, Divider$1 as Divider, Grid$1 as Grid, Input$1 as Input, InputLabel$1 as InputLabel, Link$1 as Link, List$1 as List, ListItem$1 as ListItem, Nav$1 as Nav, NavBar$1 as NavBar, NavItem$1 as NavItem, Radio$1 as Radio, RadioButtons$1 as RadioButtons, Section$1 as Section, SectionContent$1 as SectionContent, SectionHeader$1 as SectionHeader, Select$1 as Select, Snippet$1 as Snippet, Status$1 as Status, Switch$1 as Switch, Tab$1 as Tab, Table$1 as Table, TableBody$1 as TableBody, TableCell$1 as TableCell, TableFooter$1 as TableFooter, TableHead$1 as TableHead, TableRow$1 as TableRow, Tabs$1 as Tabs, TabsControl$1 as TabsControl, TabsPanel$1 as TabsPanel, Tag$1 as Tag, Text$1 as Text, Textarea$1 as Textarea };
+export { Alert, Breadcrumbs, Button, Buttons, Card, CardActions, CardContent, CardHeader, CardMedia, Checkbox, Checkboxes, Color, Display, Divider, Grid, Input, InputLabel, Link$1 as Link, List, ListItem, Nav, NavBar, NavItem, Radio, RadioButtons, Section, SectionContent, SectionHeader, Select, Snippet, Status, Switch, Tab, Table, TableBody, TableCell, TableFooter, TableHead, TableRow, Tabs, TabsControl, TabsPanel, Tag, Text, Textarea };