stone-kit 0.0.875 → 0.0.877

package/dist/node_modules/react-imask/esm/input.js

@@ -0,0 +1,25 @@
+import e from "react";
+import p from "./mixin.js";
+import "../../imask/esm/controls/input.js";
+import "../../imask/esm/masked/factory.js";
+import "../../imask/esm/controls/mask-element.js";
+import "../../imask/esm/controls/html-input-mask-element.js";
+import "../../imask/esm/controls/html-mask-element.js";
+import "../../imask/esm/controls/html-contenteditable-mask-element.js";
+import "../../imask/esm/controls/input-history.js";
+const i = p((t) => {
+  let {
+    inputRef: r,
+    ...o
+  } = t;
+  return e.createElement("input", {
+    ...o,
+    ref: r
+  });
+}), m = (t, r) => e.createElement(i, {
+  ...t,
+  ref: r
+}), k = e.forwardRef(m);
+export {
+  k as default
+};

package/dist/node_modules/react-imask/esm/mixin.js

@@ -0,0 +1,131 @@
+import o from "react";
+import e from "../../prop-types/index.js";
+import "../../imask/esm/controls/input.js";
+import p from "../../imask/esm/core/holder.js";
+import "../../imask/esm/masked/factory.js";
+import "../../imask/esm/controls/mask-element.js";
+import "../../imask/esm/controls/html-input-mask-element.js";
+import "../../imask/esm/controls/html-mask-element.js";
+import "../../imask/esm/controls/html-contenteditable-mask-element.js";
+import "../../imask/esm/controls/input-history.js";
+const m = {
+  // common
+  mask: e.oneOfType([e.array, e.func, e.string, e.instanceOf(RegExp), e.oneOf([Date, Number, p.Masked]), e.instanceOf(p.Masked)]),
+  value: e.any,
+  unmask: e.oneOfType([e.bool, e.oneOf(["typed"])]),
+  prepare: e.func,
+  prepareChar: e.func,
+  validate: e.func,
+  commit: e.func,
+  overwrite: e.oneOfType([e.bool, e.oneOf(["shift"])]),
+  eager: e.oneOfType([e.bool, e.oneOf(["append", "remove"])]),
+  skipInvalid: e.bool,
+  // events
+  onAccept: e.func,
+  onComplete: e.func,
+  // pattern
+  placeholderChar: e.string,
+  displayChar: e.string,
+  lazy: e.bool,
+  definitions: e.object,
+  blocks: e.object,
+  // enum
+  enum: e.arrayOf(e.string),
+  // range
+  maxLength: e.number,
+  from: e.number,
+  to: e.number,
+  // date
+  pattern: e.string,
+  format: e.func,
+  parse: e.func,
+  autofix: e.oneOfType([e.bool, e.oneOf(["pad"])]),
+  // number
+  radix: e.string,
+  thousandsSeparator: e.string,
+  mapToRadix: e.arrayOf(e.string),
+  scale: e.number,
+  normalizeZeros: e.bool,
+  padFractionalZeros: e.bool,
+  min: e.oneOfType([e.number, e.instanceOf(Date)]),
+  max: e.oneOfType([e.number, e.instanceOf(Date)]),
+  // dynamic
+  dispatch: e.func,
+  // ref
+  inputRef: e.oneOfType([e.func, e.shape({
+    current: e.object
+  })])
+}, u = Object.keys(m).filter((i) => i !== "value"), h = ["value", "unmask", "onAccept", "onComplete", "inputRef"], c = u.filter((i) => h.indexOf(i) < 0);
+function T(i) {
+  var a;
+  const r = (a = class extends o.Component {
+    constructor(t) {
+      super(t), this._inputRef = this._inputRef.bind(this);
+    }
+    componentDidMount() {
+      this.props.mask && this.initMask();
+    }
+    componentDidUpdate() {
+      const t = this.props, s = this._extractMaskOptionsFromProps(t);
+      if (s.mask)
+        this.maskRef ? (this.maskRef.updateOptions(s), "value" in t && t.value !== void 0 && (this.maskValue = t.value)) : this.initMask(s);
+      else if (this.destroyMask(), "value" in t && t.value !== void 0) {
+        var n;
+        (n = this.element) != null && n.isContentEditable && this.element.tagName !== "INPUT" && this.element.tagName !== "TEXTAREA" ? this.element.textContent = t.value : this.element.value = t.value;
+      }
+    }
+    componentWillUnmount() {
+      this.destroyMask();
+    }
+    _inputRef(t) {
+      this.element = t, this.props.inputRef && (Object.prototype.hasOwnProperty.call(this.props.inputRef, "current") ? this.props.inputRef.current = t : this.props.inputRef(t));
+    }
+    initMask(t) {
+      t === void 0 && (t = this._extractMaskOptionsFromProps(this.props)), this.maskRef = p(this.element, t).on("accept", this._onAccept.bind(this)).on("complete", this._onComplete.bind(this)), "value" in this.props && this.props.value !== void 0 && (this.maskValue = this.props.value);
+    }
+    destroyMask() {
+      this.maskRef && (this.maskRef.destroy(), delete this.maskRef);
+    }
+    _extractMaskOptionsFromProps(t) {
+      const {
+        ...s
+      } = t;
+      return Object.keys(s).filter((n) => c.indexOf(n) < 0).forEach((n) => {
+        delete s[n];
+      }), s;
+    }
+    _extractNonMaskProps(t) {
+      const {
+        ...s
+      } = t;
+      return u.forEach((n) => {
+        n !== "maxLength" && delete s[n];
+      }), "defaultValue" in s || (s.defaultValue = t.mask ? "" : s.value), delete s.value, s;
+    }
+    get maskValue() {
+      return this.maskRef ? this.props.unmask === "typed" ? this.maskRef.typedValue : this.props.unmask ? this.maskRef.unmaskedValue : this.maskRef.value : "";
+    }
+    set maskValue(t) {
+      this.maskRef && (t = t == null && this.props.unmask !== "typed" ? "" : t, this.props.unmask === "typed" ? this.maskRef.typedValue = t : this.props.unmask ? this.maskRef.unmaskedValue = t : this.maskRef.value = t);
+    }
+    _onAccept(t) {
+      this.props.onAccept && this.maskRef && this.props.onAccept(this.maskValue, this.maskRef, t);
+    }
+    _onComplete(t) {
+      this.props.onComplete && this.maskRef && this.props.onComplete(this.maskValue, this.maskRef, t);
+    }
+    render() {
+      return o.createElement(i, {
+        ...this._extractNonMaskProps(this.props),
+        inputRef: this._inputRef
+      });
+    }
+  }, a.displayName = void 0, a.propTypes = void 0, a), l = i.displayName || i.name || "Component";
+  return r.displayName = "IMask(" + l + ")", r.propTypes = m, o.forwardRef((f, t) => o.createElement(r, {
+    ...f,
+    ref: t
+  }));
+}
+export {
+  T as default
+};

package/dist/node_modules/react-router/dist/index.js

@@ -0,0 +1,486 @@
+import * as o from "react";
+import { UNSAFE_invariant as u, parsePath as S, matchRoutes as q, UNSAFE_warning as b, joinPaths as U, Action as j, stripBasename as X, UNSAFE_getResolveToMatches as M, resolveTo as T, isRouteErrorResponse as G } from "../../@remix-run/router/dist/router.js";
+import { createPath as ge, matchPath as ye, resolvePath as Re } from "../../@remix-run/router/dist/router.js";
+/**
+ * React Router v6.26.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 D() {
+  return D = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var r = arguments[t];
+      for (var n in r)
+        Object.prototype.hasOwnProperty.call(r, n) && (e[n] = r[n]);
+    }
+    return e;
+  }, D.apply(this, arguments);
+}
+const V = /* @__PURE__ */ o.createContext(null);
+process.env.NODE_ENV !== "production" && (V.displayName = "DataRouter");
+const k = /* @__PURE__ */ o.createContext(null);
+process.env.NODE_ENV !== "production" && (k.displayName = "DataRouterState");
+const K = /* @__PURE__ */ o.createContext(null);
+process.env.NODE_ENV !== "production" && (K.displayName = "Await");
+const C = /* @__PURE__ */ o.createContext(null);
+process.env.NODE_ENV !== "production" && (C.displayName = "Navigation");
+const O = /* @__PURE__ */ o.createContext(null);
+process.env.NODE_ENV !== "production" && (O.displayName = "Location");
+const y = /* @__PURE__ */ o.createContext({
+  outlet: null,
+  matches: [],
+  isDataRoute: !1
+});
+process.env.NODE_ENV !== "production" && (y.displayName = "Route");
+const w = /* @__PURE__ */ o.createContext(null);
+process.env.NODE_ENV !== "production" && (w.displayName = "RouteError");
+function pe(e, t) {
+  let {
+    relative: r
+  } = t === void 0 ? {} : t;
+  P() || (process.env.NODE_ENV !== "production" ? u(
+    !1,
+    // 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."
+  ) : u(!1));
+  let {
+    basename: n,
+    navigator: l
+  } = o.useContext(C), {
+    hash: s,
+    pathname: a,
+    search: f
+  } = Z(e, {
+    relative: r
+  }), m = a;
+  return n !== "/" && (m = a === "/" ? n : U([n, a])), l.createHref({
+    pathname: m,
+    search: f,
+    hash: s
+  });
+}
+function P() {
+  return o.useContext(O) != null;
+}
+function B() {
+  return P() || (process.env.NODE_ENV !== "production" ? u(
+    !1,
+    // 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."
+  ) : u(!1)), o.useContext(O).location;
+}
+const J = "You should call navigate() in a React.useEffect(), not when your component is first rendered.";
+function z(e) {
+  o.useContext(C).static || o.useLayoutEffect(e);
+}
+function he() {
+  let {
+    isDataRoute: e
+  } = o.useContext(y);
+  return e ? ue() : Q();
+}
+function Q() {
+  P() || (process.env.NODE_ENV !== "production" ? u(
+    !1,
+    // 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."
+  ) : u(!1));
+  let e = o.useContext(V), {
+    basename: t,
+    future: r,
+    navigator: n
+  } = o.useContext(C), {
+    matches: l
+  } = o.useContext(y), {
+    pathname: s
+  } = B(), a = JSON.stringify(M(l, r.v7_relativeSplatPath)), f = o.useRef(!1);
+  return z(() => {
+    f.current = !0;
+  }), o.useCallback(function(h, c) {
+    if (c === void 0 && (c = {}), process.env.NODE_ENV !== "production" && b(f.current, J), !f.current)
+      return;
+    if (typeof h == "number") {
+      n.go(h);
+      return;
+    }
+    let i = T(h, JSON.parse(a), s, c.relative === "path");
+    e == null && t !== "/" && (i.pathname = i.pathname === "/" ? t : U([t, i.pathname])), (c.replace ? n.replace : n.push)(i, c.state, c);
+  }, [t, n, a, s, e]);
+}
+function Z(e, t) {
+  let {
+    relative: r
+  } = t === void 0 ? {} : t, {
+    future: n
+  } = o.useContext(C), {
+    matches: l
+  } = o.useContext(y), {
+    pathname: s
+  } = B(), a = JSON.stringify(M(l, n.v7_relativeSplatPath));
+  return o.useMemo(() => T(e, JSON.parse(a), s, r === "path"), [e, a, s, r]);
+}
+function $(e, t) {
+  return H(e, t);
+}
+function H(e, t, r, n) {
+  P() || (process.env.NODE_ENV !== "production" ? u(
+    !1,
+    // 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."
+  ) : u(!1));
+  let {
+    navigator: l
+  } = o.useContext(C), {
+    matches: s
+  } = o.useContext(y), a = s[s.length - 1], f = a ? a.params : {}, m = a ? a.pathname : "/", h = a ? a.pathnameBase : "/", c = a && a.route;
+  if (process.env.NODE_ENV !== "production") {
+    let d = c && c.path || "";
+    Y(m, !c || d.endsWith("*"), "You rendered descendant <Routes> (or called `useRoutes()`) at " + ('"' + m + '" (under <Route path="' + d + '">) 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="' + d + '"> to <Route ') + ('path="' + (d === "/" ? "*" : d + "/*") + '">.'));
+  }
+  let i = B(), p;
+  if (t) {
+    var E;
+    let d = typeof t == "string" ? S(t) : t;
+    h === "/" || (E = d.pathname) != null && E.startsWith(h) || (process.env.NODE_ENV !== "production" ? u(!1, "When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, the location pathname must begin with the portion of the URL pathname that was " + ('matched by all parent routes. The current pathname base is "' + h + '" ') + ('but pathname "' + d.pathname + '" was given in the `location` prop.')) : u(!1)), p = d;
+  } else
+    p = i;
+  let N = p.pathname || "/", g = N;
+  if (h !== "/") {
+    let d = h.replace(/^\//, "").split("/");
+    g = "/" + N.replace(/^\//, "").split("/").slice(d.length).join("/");
+  }
+  let v = q(e, {
+    pathname: g
+  });
+  process.env.NODE_ENV !== "production" && (process.env.NODE_ENV !== "production" && b(c || v != null, 'No routes matched location "' + p.pathname + p.search + p.hash + '" '), process.env.NODE_ENV !== "production" && b(v == null || v[v.length - 1].route.element !== void 0 || v[v.length - 1].route.Component !== void 0 || v[v.length - 1].route.lazy !== void 0, 'Matched leaf route at location "' + p.pathname + p.search + p.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 x = oe(v && v.map((d) => Object.assign({}, d, {
+    params: Object.assign({}, f, d.params),
+    pathname: U([
+      h,
+      // Re-encode pathnames that were decoded inside matchRoutes
+      l.encodeLocation ? l.encodeLocation(d.pathname).pathname : d.pathname
+    ]),
+    pathnameBase: d.pathnameBase === "/" ? h : U([
+      h,
+      // Re-encode pathnames that were decoded inside matchRoutes
+      l.encodeLocation ? l.encodeLocation(d.pathnameBase).pathname : d.pathnameBase
+    ])
+  })), s, r, n);
+  return t && x ? /* @__PURE__ */ o.createElement(O.Provider, {
+    value: {
+      location: D({
+        pathname: "/",
+        search: "",
+        hash: "",
+        state: null,
+        key: "default"
+      }, p),
+      navigationType: j.Pop
+    }
+  }, x) : x;
+}
+function ee() {
+  let e = se(), t = G(e) ? e.status + " " + e.statusText : e instanceof Error ? e.message : JSON.stringify(e), r = e instanceof Error ? e.stack : null, n = "rgba(200,200,200, 0.5)", l = {
+    padding: "0.5rem",
+    backgroundColor: n
+  }, s = {
+    padding: "2px 4px",
+    backgroundColor: n
+  }, a = null;
+  return process.env.NODE_ENV !== "production" && (console.error("Error handled by React Router default ErrorBoundary:", e), a = /* @__PURE__ */ o.createElement(o.Fragment, null, /* @__PURE__ */ o.createElement("p", null, "💿 Hey developer 👋"), /* @__PURE__ */ o.createElement("p", null, "You can provide a way better UX than this when your app throws errors by providing your own ", /* @__PURE__ */ o.createElement("code", {
+    style: s
+  }, "ErrorBoundary"), " or", " ", /* @__PURE__ */ o.createElement("code", {
+    style: s
+  }, "errorElement"), " prop on your route."))), /* @__PURE__ */ o.createElement(o.Fragment, null, /* @__PURE__ */ o.createElement("h2", null, "Unexpected Application Error!"), /* @__PURE__ */ o.createElement("h3", {
+    style: {
+      fontStyle: "italic"
+    }
+  }, t), r ? /* @__PURE__ */ o.createElement("pre", {
+    style: l
+  }, r) : null, a);
+}
+const te = /* @__PURE__ */ o.createElement(ee, null);
+class re extends o.Component {
+  constructor(t) {
+    super(t), this.state = {
+      location: t.location,
+      revalidation: t.revalidation,
+      error: t.error
+    };
+  }
+  static getDerivedStateFromError(t) {
+    return {
+      error: t
+    };
+  }
+  static getDerivedStateFromProps(t, r) {
+    return r.location !== t.location || r.revalidation !== "idle" && t.revalidation === "idle" ? {
+      error: t.error,
+      location: t.location,
+      revalidation: t.revalidation
+    } : {
+      error: t.error !== void 0 ? t.error : r.error,
+      location: r.location,
+      revalidation: t.revalidation || r.revalidation
+    };
+  }
+  componentDidCatch(t, r) {
+    console.error("React Router caught the following error during render", t, r);
+  }
+  render() {
+    return this.state.error !== void 0 ? /* @__PURE__ */ o.createElement(y.Provider, {
+      value: this.props.routeContext
+    }, /* @__PURE__ */ o.createElement(w.Provider, {
+      value: this.state.error,
+      children: this.props.component
+    })) : this.props.children;
+  }
+}
+function ne(e) {
+  let {
+    routeContext: t,
+    match: r,
+    children: n
+  } = e, l = o.useContext(V);
+  return l && l.static && l.staticContext && (r.route.errorElement || r.route.ErrorBoundary) && (l.staticContext._deepestRenderedBoundaryId = r.route.id), /* @__PURE__ */ o.createElement(y.Provider, {
+    value: t
+  }, n);
+}
+function oe(e, t, r, n) {
+  var l;
+  if (t === void 0 && (t = []), r === void 0 && (r = null), n === void 0 && (n = null), e == null) {
+    var s;
+    if (!r)
+      return null;
+    if (r.errors)
+      e = r.matches;
+    else if ((s = n) != null && s.v7_partialHydration && t.length === 0 && !r.initialized && r.matches.length > 0)
+      e = r.matches;
+    else
+      return null;
+  }
+  let a = e, f = (l = r) == null ? void 0 : l.errors;
+  if (f != null) {
+    let c = a.findIndex((i) => i.route.id && (f == null ? void 0 : f[i.route.id]) !== void 0);
+    c >= 0 || (process.env.NODE_ENV !== "production" ? u(!1, "Could not find a matching route for errors on route IDs: " + Object.keys(f).join(",")) : u(!1)), a = a.slice(0, Math.min(a.length, c + 1));
+  }
+  let m = !1, h = -1;
+  if (r && n && n.v7_partialHydration)
+    for (let c = 0; c < a.length; c++) {
+      let i = a[c];
+      if ((i.route.HydrateFallback || i.route.hydrateFallbackElement) && (h = c), i.route.id) {
+        let {
+          loaderData: p,
+          errors: E
+        } = r, N = i.route.loader && p[i.route.id] === void 0 && (!E || E[i.route.id] === void 0);
+        if (i.route.lazy || N) {
+          m = !0, h >= 0 ? a = a.slice(0, h + 1) : a = [a[0]];
+          break;
+        }
+      }
+    }
+  return a.reduceRight((c, i, p) => {
+    let E, N = !1, g = null, v = null;
+    r && (E = f && i.route.id ? f[i.route.id] : void 0, g = i.route.errorElement || te, m && (h < 0 && p === 0 ? (Y("route-fallback", !1, "No `HydrateFallback` element provided to render during initial hydration"), N = !0, v = null) : h === p && (N = !0, v = i.route.hydrateFallbackElement || null)));
+    let x = t.concat(a.slice(0, p + 1)), d = () => {
+      let R;
+      return E ? R = g : N ? R = v : i.route.Component ? R = /* @__PURE__ */ o.createElement(i.route.Component, null) : i.route.element ? R = i.route.element : R = c, /* @__PURE__ */ o.createElement(ne, {
+        match: i,
+        routeContext: {
+          outlet: c,
+          matches: x,
+          isDataRoute: r != null
+        },
+        children: R
+      });
+    };
+    return r && (i.route.ErrorBoundary || i.route.errorElement || p === 0) ? /* @__PURE__ */ o.createElement(re, {
+      location: r.location,
+      revalidation: r.revalidation,
+      component: g,
+      error: E,
+      children: d(),
+      routeContext: {
+        outlet: null,
+        matches: x,
+        isDataRoute: !0
+      }
+    }) : d();
+  }, null);
+}
+var W = /* @__PURE__ */ function(e) {
+  return e.UseBlocker = "useBlocker", e.UseRevalidator = "useRevalidator", e.UseNavigateStable = "useNavigate", e;
+}(W || {}), _ = /* @__PURE__ */ function(e) {
+  return e.UseBlocker = "useBlocker", e.UseLoaderData = "useLoaderData", e.UseActionData = "useActionData", e.UseRouteError = "useRouteError", e.UseNavigation = "useNavigation", e.UseRouteLoaderData = "useRouteLoaderData", e.UseMatches = "useMatches", e.UseRevalidator = "useRevalidator", e.UseNavigateStable = "useNavigate", e.UseRouteId = "useRouteId", e;
+}(_ || {});
+function I(e) {
+  return e + " must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.";
+}
+function ae(e) {
+  let t = o.useContext(V);
+  return t || (process.env.NODE_ENV !== "production" ? u(!1, I(e)) : u(!1)), t;
+}
+function ie(e) {
+  let t = o.useContext(k);
+  return t || (process.env.NODE_ENV !== "production" ? u(!1, I(e)) : u(!1)), t;
+}
+function le(e) {
+  let t = o.useContext(y);
+  return t || (process.env.NODE_ENV !== "production" ? u(!1, I(e)) : u(!1)), t;
+}
+function L(e) {
+  let t = le(e), r = t.matches[t.matches.length - 1];
+  return r.route.id || (process.env.NODE_ENV !== "production" ? u(!1, e + ' can only be used on routes that contain a unique "id"') : u(!1)), r.route.id;
+}
+function fe() {
+  return L(_.UseRouteId);
+}
+function se() {
+  var e;
+  let t = o.useContext(w), r = ie(_.UseRouteError), n = L(_.UseRouteError);
+  return t !== void 0 ? t : (e = r.errors) == null ? void 0 : e[n];
+}
+function ue() {
+  let {
+    router: e
+  } = ae(W.UseNavigateStable), t = L(_.UseNavigateStable), r = o.useRef(!1);
+  return z(() => {
+    r.current = !0;
+  }), o.useCallback(function(l, s) {
+    s === void 0 && (s = {}), process.env.NODE_ENV !== "production" && b(r.current, J), r.current && (typeof l == "number" ? e.navigate(l) : e.navigate(l, D({
+      fromRouteId: t
+    }, s)));
+  }, [e, t]);
+}
+const A = {};
+function Y(e, t, r) {
+  !t && !A[e] && (A[e] = !0, process.env.NODE_ENV !== "production" && b(!1, r));
+}
+function ce(e) {
+  process.env.NODE_ENV !== "production" ? u(!1, "A <Route> is only ever to be used as the child of <Routes> element, never rendered directly. Please wrap your <Route> in a <Routes>.") : u(!1);
+}
+function ve(e) {
+  let {
+    basename: t = "/",
+    children: r = null,
+    location: n,
+    navigationType: l = j.Pop,
+    navigator: s,
+    static: a = !1,
+    future: f
+  } = e;
+  P() && (process.env.NODE_ENV !== "production" ? u(!1, "You cannot render a <Router> inside another <Router>. You should never have more than one in your app.") : u(!1));
+  let m = t.replace(/^\/*/, "/"), h = o.useMemo(() => ({
+    basename: m,
+    navigator: s,
+    static: a,
+    future: D({
+      v7_relativeSplatPath: !1
+    }, f)
+  }), [m, f, s, a]);
+  typeof n == "string" && (n = S(n));
+  let {
+    pathname: c = "/",
+    search: i = "",
+    hash: p = "",
+    state: E = null,
+    key: N = "default"
+  } = n, g = o.useMemo(() => {
+    let v = X(c, m);
+    return v == null ? null : {
+      location: {
+        pathname: v,
+        search: i,
+        hash: p,
+        state: E,
+        key: N
+      },
+      navigationType: l
+    };
+  }, [m, c, i, p, E, N, l]);
+  return process.env.NODE_ENV !== "production" && b(g != null, '<Router basename="' + m + '"> is not able to match the URL ' + ('"' + c + i + p + '" because it does not start with the ') + "basename, so the <Router> won't render anything."), g == null ? null : /* @__PURE__ */ o.createElement(C.Provider, {
+    value: h
+  }, /* @__PURE__ */ o.createElement(O.Provider, {
+    children: r,
+    value: g
+  }));
+}
+function me(e) {
+  let {
+    children: t,
+    location: r
+  } = e;
+  return $(F(t), r);
+}
+new Promise(() => {
+});
+function F(e, t) {
+  t === void 0 && (t = []);
+  let r = [];
+  return o.Children.forEach(e, (n, l) => {
+    if (!/* @__PURE__ */ o.isValidElement(n))
+      return;
+    let s = [...t, l];
+    if (n.type === o.Fragment) {
+      r.push.apply(r, F(n.props.children, s));
+      return;
+    }
+    n.type !== ce && (process.env.NODE_ENV !== "production" ? u(!1, "[" + (typeof n.type == "string" ? n.type : n.type.name) + "] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>") : u(!1)), !n.props.index || !n.props.children || (process.env.NODE_ENV !== "production" ? u(!1, "An index route cannot have child routes.") : u(!1));
+    let a = {
+      id: n.props.id || s.join("-"),
+      caseSensitive: n.props.caseSensitive,
+      element: n.props.element,
+      Component: n.props.Component,
+      index: n.props.index,
+      path: n.props.path,
+      loader: n.props.loader,
+      action: n.props.action,
+      errorElement: n.props.errorElement,
+      ErrorBoundary: n.props.ErrorBoundary,
+      hasErrorBoundary: n.props.ErrorBoundary != null || n.props.errorElement != null,
+      shouldRevalidate: n.props.shouldRevalidate,
+      handle: n.props.handle,
+      lazy: n.props.lazy
+    };
+    n.props.children && (a.children = F(n.props.children, s)), r.push(a);
+  }), r;
+}
+export {
+  j as NavigationType,
+  ce as Route,
+  ve as Router,
+  me as Routes,
+  V as UNSAFE_DataRouterContext,
+  k as UNSAFE_DataRouterStateContext,
+  O as UNSAFE_LocationContext,
+  C as UNSAFE_NavigationContext,
+  y as UNSAFE_RouteContext,
+  fe as UNSAFE_useRouteId,
+  H as UNSAFE_useRoutesImpl,
+  ge as createPath,
+  F as createRoutesFromChildren,
+  F as createRoutesFromElements,
+  G as isRouteErrorResponse,
+  ye as matchPath,
+  q as matchRoutes,
+  S as parsePath,
+  Re as resolvePath,
+  pe as useHref,
+  P as useInRouterContext,
+  B as useLocation,
+  he as useNavigate,
+  Z as useResolvedPath,
+  se as useRouteError,
+  $ as useRoutes
+};