storybook 9.0.0-alpha.1 → 9.0.0-alpha.10

package/dist/router/index.cjs

@@ -0,0 +1,3296 @@
+"use strict";
+var Nr = Object.create;
+var je = Object.defineProperty;
+var Lr = Object.getOwnPropertyDescriptor;
+var _r = Object.getOwnPropertyNames;
+var Mr = Object.getPrototypeOf, Tr = Object.prototype.hasOwnProperty;
+var r = (e, t) => je(e, "name", { value: t, configurable: !0 });
+var ne = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), kr = (e, t) => {
+  for (var a in t)
+    je(e, a, { get: t[a], enumerable: !0 });
+}, ft = (e, t, a, n) => {
+  if (t && typeof t == "object" || typeof t == "function")
+    for (let l of _r(t))
+      !Tr.call(e, l) && l !== a && je(e, l, { get: () => t[l], enumerable: !(n = Lr(t, l)) || n.enumerable });
+  return e;
+};
+var we = (e, t, a) => (a = e != null ? Nr(Mr(e)) : {}, ft(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  t || !e || !e.__esModule ? je(a, "default", { value: e, enumerable: !0 }) : a,
+  e
+)), Ir = (e) => ft(je({}, "__esModule", { value: !0 }), e);
+
+// ../node_modules/map-or-similar/src/similar.js
+var Bt = ne((Fn, It) => {
+  function be() {
+    return this.list = [], this.lastItem = void 0, this.size = 0, this;
+  }
+  r(be, "Similar");
+  be.prototype.get = function(e) {
+    var t;
+    if (this.lastItem && this.isEqual(this.lastItem.key, e))
+      return this.lastItem.val;
+    if (t = this.indexOf(e), t >= 0)
+      return this.lastItem = this.list[t], this.list[t].val;
+  };
+  be.prototype.set = function(e, t) {
+    var a;
+    return this.lastItem && this.isEqual(this.lastItem.key, e) ? (this.lastItem.val = t, this) : (a = this.indexOf(e), a >= 0 ? (this.lastItem =
+    this.list[a], this.list[a].val = t, this) : (this.lastItem = { key: e, val: t }, this.list.push(this.lastItem), this.size++, this));
+  };
+  be.prototype.delete = function(e) {
+    var t;
+    if (this.lastItem && this.isEqual(this.lastItem.key, e) && (this.lastItem = void 0), t = this.indexOf(e), t >= 0)
+      return this.size--, this.list.splice(t, 1)[0];
+  };
+  be.prototype.has = function(e) {
+    var t;
+    return this.lastItem && this.isEqual(this.lastItem.key, e) ? !0 : (t = this.indexOf(e), t >= 0 ? (this.lastItem = this.list[t], !0) : !1);
+  };
+  be.prototype.forEach = function(e, t) {
+    var a;
+    for (a = 0; a < this.size; a++)
+      e.call(t || this, this.list[a].val, this.list[a].key, this);
+  };
+  be.prototype.indexOf = function(e) {
+    var t;
+    for (t = 0; t < this.size; t++)
+      if (this.isEqual(this.list[t].key, e))
+        return t;
+    return -1;
+  };
+  be.prototype.isEqual = function(e, t) {
+    return e === t || e !== e && t !== t;
+  };
+  It.exports = be;
+});
+
+// ../node_modules/map-or-similar/src/map-or-similar.js
+var Wt = ne((zn, Dt) => {
+  Dt.exports = function(e) {
+    if (typeof Map != "function" || e) {
+      var t = Bt();
+      return new t();
+    } else
+      return /* @__PURE__ */ new Map();
+  };
+});
+
+// ../node_modules/memoizerific/src/memoizerific.js
+var $t = ne((qn, Ft) => {
+  var Ht = Wt();
+  Ft.exports = function(e) {
+    var t = new Ht(process.env.FORCE_SIMILAR_INSTEAD_OF_MAP === "true"), a = [];
+    return function(n) {
+      var l = /* @__PURE__ */ r(function() {
+        var v = t, z, B, U = arguments.length - 1, J = Array(U + 1), F = !0, x;
+        if ((l.numArgs || l.numArgs === 0) && l.numArgs !== U + 1)
+          throw new Error("Memoizerific functions should always be called with the same number of arguments");
+        for (x = 0; x < U; x++) {
+          if (J[x] = {
+            cacheItem: v,
+            arg: arguments[x]
+          }, v.has(arguments[x])) {
+            v = v.get(arguments[x]);
+            continue;
+          }
+          F = !1, z = new Ht(process.env.FORCE_SIMILAR_INSTEAD_OF_MAP === "true"), v.set(arguments[x], z), v = z;
+        }
+        return F && (v.has(arguments[U]) ? B = v.get(arguments[U]) : F = !1), F || (B = n.apply(null, arguments), v.set(arguments[U], B)), e >
+        0 && (J[U] = {
+          cacheItem: v,
+          arg: arguments[U]
+        }, F ? Br(a, J) : a.push(J), a.length > e && Dr(a.shift())), l.wasMemoized = F, l.numArgs = U + 1, B;
+      }, "memoizerific");
+      return l.limit = e, l.wasMemoized = !1, l.cache = t, l.lru = a, l;
+    };
+  };
+  function Br(e, t) {
+    var a = e.length, n = t.length, l, v, z;
+    for (v = 0; v < a; v++) {
+      for (l = !0, z = 0; z < n; z++)
+        if (!Wr(e[v][z].arg, t[z].arg)) {
+          l = !1;
+          break;
+        }
+      if (l)
+        break;
+    }
+    e.push(e.splice(v, 1)[0]);
+  }
+  r(Br, "moveToMostRecentLru");
+  function Dr(e) {
+    var t = e.length, a = e[t - 1], n, l;
+    for (a.cacheItem.delete(a.arg), l = t - 2; l >= 0 && (a = e[l], n = a.cacheItem.get(a.arg), !n || !n.size); l--)
+      a.cacheItem.delete(a.arg);
+  }
+  r(Dr, "removeCachedResult");
+  function Wr(e, t) {
+    return e === t || e !== e && t !== t;
+  }
+  r(Wr, "isEqual");
+});
+
+// ../node_modules/picoquery/lib/string-util.js
+var Je = ne((Ke) => {
+  "use strict";
+  Object.defineProperty(Ke, "__esModule", { value: !0 });
+  Ke.encodeString = Fr;
+  var he = Array.from({ length: 256 }, (e, t) => "%" + ((t < 16 ? "0" : "") + t.toString(16)).toUpperCase()), Hr = new Int8Array([
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    1,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    1,
+    0
+  ]);
+  function Fr(e) {
+    let t = e.length;
+    if (t === 0)
+      return "";
+    let a = "", n = 0, l = 0;
+    e: for (; l < t; l++) {
+      let v = e.charCodeAt(l);
+      for (; v < 128; ) {
+        if (Hr[v] !== 1 && (n < l && (a += e.slice(n, l)), n = l + 1, a += he[v]), ++l === t)
+          break e;
+        v = e.charCodeAt(l);
+      }
+      if (n < l && (a += e.slice(n, l)), v < 2048) {
+        n = l + 1, a += he[192 | v >> 6] + he[128 | v & 63];
+        continue;
+      }
+      if (v < 55296 || v >= 57344) {
+        n = l + 1, a += he[224 | v >> 12] + he[128 | v >> 6 & 63] + he[128 | v & 63];
+        continue;
+      }
+      if (++l, l >= t)
+        throw new Error("URI malformed");
+      let z = e.charCodeAt(l) & 1023;
+      n = l + 1, v = 65536 + ((v & 1023) << 10 | z), a += he[240 | v >> 18] + he[128 | v >> 12 & 63] + he[128 | v >> 6 & 63] + he[128 | v & 63];
+    }
+    return n === 0 ? e : n < t ? a + e.slice(n) : a;
+  }
+  r(Fr, "encodeString");
+});
+
+// ../node_modules/picoquery/lib/shared.js
+var Ne = ne((pe) => {
+  "use strict";
+  Object.defineProperty(pe, "__esModule", { value: !0 });
+  pe.defaultOptions = pe.defaultShouldSerializeObject = pe.defaultValueSerializer = void 0;
+  var Qe = Je(), $r = /* @__PURE__ */ r((e) => {
+    switch (typeof e) {
+      case "string":
+        return (0, Qe.encodeString)(e);
+      case "bigint":
+      case "boolean":
+        return "" + e;
+      case "number":
+        if (Number.isFinite(e))
+          return e < 1e21 ? "" + e : (0, Qe.encodeString)("" + e);
+        break;
+    }
+    return e instanceof Date ? (0, Qe.encodeString)(e.toISOString()) : "";
+  }, "defaultValueSerializer");
+  pe.defaultValueSerializer = $r;
+  var zr = /* @__PURE__ */ r((e) => e instanceof Date, "defaultShouldSerializeObject");
+  pe.defaultShouldSerializeObject = zr;
+  var zt = /* @__PURE__ */ r((e) => e, "identityFunc");
+  pe.defaultOptions = {
+    nesting: !0,
+    nestingSyntax: "dot",
+    arrayRepeat: !1,
+    arrayRepeatSyntax: "repeat",
+    delimiter: 38,
+    valueDeserializer: zt,
+    valueSerializer: pe.defaultValueSerializer,
+    keyDeserializer: zt,
+    shouldSerializeObject: pe.defaultShouldSerializeObject
+  };
+});
+
+// ../node_modules/picoquery/lib/object-util.js
+var Ye = ne((Le) => {
+  "use strict";
+  Object.defineProperty(Le, "__esModule", { value: !0 });
+  Le.getDeepObject = Vr;
+  Le.stringifyObject = qt;
+  var Pe = Ne(), qr = Je();
+  function Ur(e) {
+    return e === "__proto__" || e === "constructor" || e === "prototype";
+  }
+  r(Ur, "isPrototypeKey");
+  function Vr(e, t, a, n, l) {
+    if (Ur(t))
+      return e;
+    let v = e[t];
+    return typeof v == "object" && v !== null ? v : !n && (l || typeof a == "number" || typeof a == "string" && a * 0 === 0 && a.indexOf(".") ===
+    -1) ? e[t] = [] : e[t] = {};
+  }
+  r(Vr, "getDeepObject");
+  var Kr = 20, Jr = "[]", Qr = "[", Yr = "]", Xr = ".";
+  function qt(e, t, a = 0, n, l) {
+    let { nestingSyntax: v = Pe.defaultOptions.nestingSyntax, arrayRepeat: z = Pe.defaultOptions.arrayRepeat, arrayRepeatSyntax: B = Pe.defaultOptions.
+    arrayRepeatSyntax, nesting: U = Pe.defaultOptions.nesting, delimiter: J = Pe.defaultOptions.delimiter, valueSerializer: F = Pe.defaultOptions.
+    valueSerializer, shouldSerializeObject: x = Pe.defaultOptions.shouldSerializeObject } = t, O = typeof J == "number" ? String.fromCharCode(
+    J) : J, j = l === !0 && z, E = v === "dot" || v === "js" && !l;
+    if (a > Kr)
+      return "";
+    let L = "", s = !0, i = !1;
+    for (let h in e) {
+      let c = e[h], y;
+      n ? (y = n, j ? B === "bracket" && (y += Jr) : E ? (y += Xr, y += h) : (y += Qr, y += h, y += Yr)) : y = h, s || (L += O), typeof c ==
+      "object" && c !== null && !x(c) ? (i = c.pop !== void 0, (U || z && i) && (L += qt(c, t, a + 1, y, i))) : (L += (0, qr.encodeString)(y),
+      L += "=", L += F(c, h)), s && (s = !1);
+    }
+    return L;
+  }
+  r(qt, "stringifyObject");
+});
+
+// ../node_modules/fast-decode-uri-component/index.js
+var Jt = ne((Gn, Kt) => {
+  "use strict";
+  var Ut = 12, Gr = 0, Xe = [
+    // The first part of the table maps bytes to character to a transition.
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    4,
+    4,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    6,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    8,
+    7,
+    7,
+    10,
+    9,
+    9,
+    9,
+    11,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    // The second part of the table maps a state to a new state when adding a
+    // transition.
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    12,
+    0,
+    0,
+    0,
+    0,
+    24,
+    36,
+    48,
+    60,
+    72,
+    84,
+    96,
+    0,
+    12,
+    12,
+    12,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    24,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    24,
+    24,
+    24,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    24,
+    24,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    48,
+    48,
+    48,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    48,
+    48,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    48,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    // The third part maps the current transition to a mask that needs to apply
+    // to the byte.
+    127,
+    63,
+    63,
+    63,
+    0,
+    31,
+    15,
+    15,
+    15,
+    7,
+    7,
+    7
+  ];
+  function Zr(e) {
+    var t = e.indexOf("%");
+    if (t === -1) return e;
+    for (var a = e.length, n = "", l = 0, v = 0, z = t, B = Ut; t > -1 && t < a; ) {
+      var U = Vt(e[t + 1], 4), J = Vt(e[t + 2], 0), F = U | J, x = Xe[F];
+      if (B = Xe[256 + B + x], v = v << 6 | F & Xe[364 + x], B === Ut)
+        n += e.slice(l, z), n += v <= 65535 ? String.fromCharCode(v) : String.fromCharCode(
+          55232 + (v >> 10),
+          56320 + (v & 1023)
+        ), v = 0, l = t + 3, t = z = e.indexOf("%", l);
+      else {
+        if (B === Gr)
+          return null;
+        if (t += 3, t < a && e.charCodeAt(t) === 37) continue;
+        return null;
+      }
+    }
+    return n + e.slice(l);
+  }
+  r(Zr, "decodeURIComponent");
+  var en = {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+    5: 5,
+    6: 6,
+    7: 7,
+    8: 8,
+    9: 9,
+    a: 10,
+    A: 10,
+    b: 11,
+    B: 11,
+    c: 12,
+    C: 12,
+    d: 13,
+    D: 13,
+    e: 14,
+    E: 14,
+    f: 15,
+    F: 15
+  };
+  function Vt(e, t) {
+    var a = en[e];
+    return a === void 0 ? 255 : a << t;
+  }
+  r(Vt, "hexCodeToInt");
+  Kt.exports = Zr;
+});
+
+// ../node_modules/picoquery/lib/parse.js
+var Gt = ne((ye) => {
+  "use strict";
+  var tn = ye && ye.__importDefault || function(e) {
+    return e && e.__esModule ? e : { default: e };
+  };
+  Object.defineProperty(ye, "__esModule", { value: !0 });
+  ye.numberValueDeserializer = ye.numberKeyDeserializer = void 0;
+  ye.parse = an;
+  var _e = Ye(), Oe = Ne(), Qt = tn(Jt()), rn = /* @__PURE__ */ r((e) => {
+    let t = Number(e);
+    return Number.isNaN(t) ? e : t;
+  }, "numberKeyDeserializer");
+  ye.numberKeyDeserializer = rn;
+  var nn = /* @__PURE__ */ r((e) => {
+    let t = Number(e);
+    return Number.isNaN(t) ? e : t;
+  }, "numberValueDeserializer");
+  ye.numberValueDeserializer = nn;
+  var Yt = /\+/g, Xt = /* @__PURE__ */ r(function() {
+  }, "Empty");
+  Xt.prototype = /* @__PURE__ */ Object.create(null);
+  function Me(e, t, a, n, l) {
+    let v = e.substring(t, a);
+    return n && (v = v.replace(Yt, " ")), l && (v = (0, Qt.default)(v) || v), v;
+  }
+  r(Me, "computeKeySlice");
+  function an(e, t) {
+    let { valueDeserializer: a = Oe.defaultOptions.valueDeserializer, keyDeserializer: n = Oe.defaultOptions.keyDeserializer, arrayRepeatSyntax: l = Oe.
+    defaultOptions.arrayRepeatSyntax, nesting: v = Oe.defaultOptions.nesting, arrayRepeat: z = Oe.defaultOptions.arrayRepeat, nestingSyntax: B = Oe.
+    defaultOptions.nestingSyntax, delimiter: U = Oe.defaultOptions.delimiter } = t ?? {}, J = typeof U == "string" ? U.charCodeAt(0) : U, F = B ===
+    "js", x = new Xt();
+    if (typeof e != "string")
+      return x;
+    let O = e.length, j = "", E = -1, L = -1, s = -1, i = x, h, c = "", y = "", S = !1, N = !1, I = !1, W = !1, Y = !1, _ = !1, V = !1, $ = 0,
+    w = -1, P = -1, H = -1;
+    for (let o = 0; o < O + 1; o++) {
+      if ($ = o !== O ? e.charCodeAt(o) : J, $ === J) {
+        if (V = L > E, V || (L = o), s !== L - 1 && (y = Me(e, s + 1, w > -1 ? w : L, I, S), c = n(y), h !== void 0 && (i = (0, _e.getDeepObject)(
+        i, h, c, F && Y, F && _))), V || c !== "") {
+          V && (j = e.slice(L + 1, o), W && (j = j.replace(Yt, " ")), N && (j = (0, Qt.default)(j) || j));
+          let u = a(j, c);
+          if (z) {
+            let g = i[c];
+            g === void 0 ? w > -1 ? i[c] = [u] : i[c] = u : g.pop ? g.push(u) : i[c] = [g, u];
+          } else
+            i[c] = u;
+        }
+        j = "", E = o, L = o, S = !1, N = !1, I = !1, W = !1, Y = !1, _ = !1, w = -1, s = o, i = x, h = void 0, c = "";
+      } else $ === 93 ? (z && l === "bracket" && H === 91 && (w = P), v && (B === "index" || F) && L <= E && (s !== P && (y = Me(e, s + 1, o,
+      I, S), c = n(y), h !== void 0 && (i = (0, _e.getDeepObject)(i, h, c, void 0, F)), h = c, I = !1, S = !1), s = o, _ = !0, Y = !1)) : $ ===
+      46 ? v && (B === "dot" || F) && L <= E && (s !== P && (y = Me(e, s + 1, o, I, S), c = n(y), h !== void 0 && (i = (0, _e.getDeepObject)(
+      i, h, c, F)), h = c, I = !1, S = !1), Y = !0, _ = !1, s = o) : $ === 91 ? v && (B === "index" || F) && L <= E && (s !== P && (y = Me(e,
+      s + 1, o, I, S), c = n(y), F && h !== void 0 && (i = (0, _e.getDeepObject)(i, h, c, F)), h = c, I = !1, S = !1, Y = !1, _ = !0), s = o) :
+      $ === 61 ? L <= E ? L = o : N = !0 : $ === 43 ? L > E ? W = !0 : I = !0 : $ === 37 && (L > E ? N = !0 : S = !0);
+      P = o, H = $;
+    }
+    return x;
+  }
+  r(an, "parse");
+});
+
+// ../node_modules/picoquery/lib/stringify.js
+var Zt = ne((Ge) => {
+  "use strict";
+  Object.defineProperty(Ge, "__esModule", { value: !0 });
+  Ge.stringify = sn;
+  var on = Ye();
+  function sn(e, t) {
+    if (e === null || typeof e != "object")
+      return "";
+    let a = t ?? {};
+    return (0, on.stringifyObject)(e, a);
+  }
+  r(sn, "stringify");
+});
+
+// ../node_modules/picoquery/lib/main.js
+var er = ne((fe) => {
+  "use strict";
+  var un = fe && fe.__createBinding || (Object.create ? function(e, t, a, n) {
+    n === void 0 && (n = a);
+    var l = Object.getOwnPropertyDescriptor(t, a);
+    (!l || ("get" in l ? !t.__esModule : l.writable || l.configurable)) && (l = { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return t[a];
+    }, "get") }), Object.defineProperty(e, n, l);
+  } : function(e, t, a, n) {
+    n === void 0 && (n = a), e[n] = t[a];
+  }), ln = fe && fe.__exportStar || function(e, t) {
+    for (var a in e) a !== "default" && !Object.prototype.hasOwnProperty.call(t, a) && un(t, e, a);
+  };
+  Object.defineProperty(fe, "__esModule", { value: !0 });
+  fe.stringify = fe.parse = void 0;
+  var cn = Gt();
+  Object.defineProperty(fe, "parse", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+    return cn.parse;
+  }, "get") });
+  var fn = Zt();
+  Object.defineProperty(fe, "stringify", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+    return fn.stringify;
+  }, "get") });
+  ln(Ne(), fe);
+});
+
+// ../node_modules/ts-dedent/dist/index.js
+var rr = ne((Se) => {
+  "use strict";
+  Object.defineProperty(Se, "__esModule", { value: !0 });
+  Se.dedent = void 0;
+  function tr(e) {
+    for (var t = [], a = 1; a < arguments.length; a++)
+      t[a - 1] = arguments[a];
+    var n = Array.from(typeof e == "string" ? [e] : e);
+    n[n.length - 1] = n[n.length - 1].replace(/\r?\n([\t ]*)$/, "");
+    var l = n.reduce(function(B, U) {
+      var J = U.match(/\n([\t ]+|(?!\s).)/g);
+      return J ? B.concat(J.map(function(F) {
+        var x, O;
+        return (O = (x = F.match(/[\t ]/g)) === null || x === void 0 ? void 0 : x.length) !== null && O !== void 0 ? O : 0;
+      })) : B;
+    }, []);
+    if (l.length) {
+      var v = new RegExp(`
+[	 ]{` + Math.min.apply(Math, l) + "}", "g");
+      n = n.map(function(B) {
+        return B.replace(v, `
+`);
+      });
+    }
+    n[0] = n[0].replace(/^\r?\n/, "");
+    var z = n[0];
+    return t.forEach(function(B, U) {
+      var J = z.match(/(?:^|\n)( *)$/), F = J ? J[1] : "", x = B;
+      typeof B == "string" && B.includes(`
+`) && (x = String(B).split(`
+`).map(function(O, j) {
+        return j === 0 ? O : "" + F + O;
+      }).join(`
+`)), z += x + n[U + 1];
+    }), z;
+  }
+  r(tr, "dedent");
+  Se.dedent = tr;
+  Se.default = tr;
+});
+
+// ../node_modules/history/umd/history.production.min.js
+var lr = ne((Ie, ur) => {
+  (function(e, t) {
+    typeof Ie == "object" && typeof ur < "u" ? t(Ie) : typeof define == "function" && define.amd ? define(["exports"], t) : t((e = typeof globalThis <
+    "u" ? globalThis : e || self).HistoryLibrary = {});
+  })(Ie, function(e) {
+    "use strict";
+    function t() {
+      return (t = Object.assign || function(x) {
+        for (var O = 1; O < arguments.length; O++) {
+          var j = arguments[O];
+          for (var E in j) Object.prototype.hasOwnProperty.call(j, E) && (x[E] = j[E]);
+        }
+        return x;
+      }).apply(this, arguments);
+    }
+    r(t, "n");
+    var a;
+    e.Action = void 0, (a = e.Action || (e.Action = {})).Pop = "POP", a.Push = "PUSH", a.Replace = "REPLACE";
+    var n = "beforeunload", l = "popstate";
+    function v(x, O, j) {
+      return Math.min(Math.max(x, O), j);
+    }
+    r(v, "a");
+    function z(x) {
+      x.preventDefault(), x.returnValue = "";
+    }
+    r(z, "i");
+    function B() {
+      var x = [];
+      return { get length() {
+        return x.length;
+      }, push: /* @__PURE__ */ r(function(O) {
+        return x.push(O), function() {
+          x = x.filter(function(j) {
+            return j !== O;
+          });
+        };
+      }, "push"), call: /* @__PURE__ */ r(function(O) {
+        x.forEach(function(j) {
+          return j && j(O);
+        });
+      }, "call") };
+    }
+    r(B, "c");
+    function U() {
+      return Math.random().toString(36).substr(2, 8);
+    }
+    r(U, "u");
+    function J(x) {
+      var O = x.pathname, j = O === void 0 ? "/" : O, E = x.search, L = E === void 0 ? "" : E, s = x.hash, i = s === void 0 ? "" : s;
+      return L && L !== "?" && (j += L.charAt(0) === "?" ? L : "?" + L), i && i !== "#" && (j += i.charAt(0) === "#" ? i : "#" + i), j;
+    }
+    r(J, "l");
+    function F(x) {
+      var O = {};
+      if (x) {
+        var j = x.indexOf("#");
+        j >= 0 && (O.hash = x.substr(j), x = x.substr(0, j));
+        var E = x.indexOf("?");
+        E >= 0 && (O.search = x.substr(E), x = x.substr(0, E)), x && (O.pathname = x);
+      }
+      return O;
+    }
+    r(F, "f"), e.createBrowserHistory = function(x) {
+      x === void 0 && (x = {});
+      var O = x.window, j = O === void 0 ? document.defaultView : O, E = j.history;
+      function L() {
+        var w = j.location, P = w.pathname, H = w.search, o = w.hash, u = E.state || {};
+        return [u.idx, { pathname: P, search: H, hash: o, state: u.usr || null, key: u.key || "default" }];
+      }
+      r(L, "p");
+      var s = null;
+      j.addEventListener(l, function() {
+        if (s) N.call(s), s = null;
+        else {
+          var w = e.Action.Pop, P = L(), H = P[0], o = P[1];
+          if (N.length) {
+            if (H != null) {
+              var u = c - H;
+              u && (s = { action: w, location: o, retry: /* @__PURE__ */ r(function() {
+                $(-1 * u);
+              }, "retry") }, $(u));
+            }
+          } else V(w);
+        }
+      });
+      var i = e.Action.Pop, h = L(), c = h[0], y = h[1], S = B(), N = B();
+      function I(w) {
+        return typeof w == "string" ? w : J(w);
+      }
+      r(I, "P");
+      function W(w, P) {
+        return P === void 0 && (P = null), t({ pathname: y.pathname, hash: "", search: "" }, typeof w == "string" ? F(w) : w, { state: P, key: U() });
+      }
+      r(W, "k");
+      function Y(w, P) {
+        return [{ usr: w.state, key: w.key, idx: P }, I(w)];
+      }
+      r(Y, "x");
+      function _(w, P, H) {
+        return !N.length || (N.call({ action: w, location: P, retry: H }), !1);
+      }
+      r(_, "w");
+      function V(w) {
+        i = w;
+        var P = L();
+        c = P[0], y = P[1], S.call({ action: i, location: y });
+      }
+      r(V, "E");
+      function $(w) {
+        E.go(w);
+      }
+      return r($, "H"), c == null && (c = 0, E.replaceState(t({}, E.state, { idx: c }), "")), { get action() {
+        return i;
+      }, get location() {
+        return y;
+      }, createHref: I, push: /* @__PURE__ */ r(function w(P, H) {
+        var o = e.Action.Push, u = W(P, H);
+        if (_(o, u, function() {
+          w(P, H);
+        })) {
+          var g = Y(u, c + 1), d = g[0], m = g[1];
+          try {
+            E.pushState(d, "", m);
+          } catch {
+            j.location.assign(m);
+          }
+          V(o);
+        }
+      }, "n"), replace: /* @__PURE__ */ r(function w(P, H) {
+        var o = e.Action.Replace, u = W(P, H);
+        if (_(o, u, function() {
+          w(P, H);
+        })) {
+          var g = Y(u, c), d = g[0], m = g[1];
+          E.replaceState(d, "", m), V(o);
+        }
+      }, "n"), go: $, back: /* @__PURE__ */ r(function() {
+        $(-1);
+      }, "back"), forward: /* @__PURE__ */ r(function() {
+        $(1);
+      }, "forward"), listen: /* @__PURE__ */ r(function(w) {
+        return S.push(w);
+      }, "listen"), block: /* @__PURE__ */ r(function(w) {
+        var P = N.push(w);
+        return N.length === 1 && j.addEventListener(n, z), function() {
+          P(), N.length || j.removeEventListener(n, z);
+        };
+      }, "block") };
+    }, e.createHashHistory = function(x) {
+      x === void 0 && (x = {});
+      var O = x.window, j = O === void 0 ? document.defaultView : O, E = j.history;
+      function L() {
+        var P = F(j.location.hash.substr(1)), H = P.pathname, o = H === void 0 ? "/" : H, u = P.search, g = u === void 0 ? "" : u, d = P.hash,
+        m = d === void 0 ? "" : d, T = E.state || {};
+        return [T.idx, { pathname: o, search: g, hash: m, state: T.usr || null, key: T.key || "default" }];
+      }
+      r(L, "p");
+      var s = null;
+      function i() {
+        if (s) I.call(s), s = null;
+        else {
+          var P = e.Action.Pop, H = L(), o = H[0], u = H[1];
+          if (I.length) {
+            if (o != null) {
+              var g = y - o;
+              g && (s = { action: P, location: u, retry: /* @__PURE__ */ r(function() {
+                w(-1 * g);
+              }, "retry") }, w(g));
+            }
+          } else $(P);
+        }
+      }
+      r(i, "d"), j.addEventListener(l, i), j.addEventListener("hashchange", function() {
+        J(L()[1]) !== J(S) && i();
+      });
+      var h = e.Action.Pop, c = L(), y = c[0], S = c[1], N = B(), I = B();
+      function W(P) {
+        return function() {
+          var H = document.querySelector("base"), o = "";
+          if (H && H.getAttribute("href")) {
+            var u = j.location.href, g = u.indexOf("#");
+            o = g === -1 ? u : u.slice(0, g);
+          }
+          return o;
+        }() + "#" + (typeof P == "string" ? P : J(P));
+      }
+      r(W, "k");
+      function Y(P, H) {
+        return H === void 0 && (H = null), t({ pathname: S.pathname, hash: "", search: "" }, typeof P == "string" ? F(P) : P, { state: H, key: U() });
+      }
+      r(Y, "x");
+      function _(P, H) {
+        return [{ usr: P.state, key: P.key, idx: H }, W(P)];
+      }
+      r(_, "w");
+      function V(P, H, o) {
+        return !I.length || (I.call({ action: P, location: H, retry: o }), !1);
+      }
+      r(V, "E");
+      function $(P) {
+        h = P;
+        var H = L();
+        y = H[0], S = H[1], N.call({ action: h, location: S });
+      }
+      r($, "H");
+      function w(P) {
+        E.go(P);
+      }
+      return r(w, "L"), y == null && (y = 0, E.replaceState(t({}, E.state, { idx: y }), "")), { get action() {
+        return h;
+      }, get location() {
+        return S;
+      }, createHref: W, push: /* @__PURE__ */ r(function P(H, o) {
+        var u = e.Action.Push, g = Y(H, o);
+        if (V(u, g, function() {
+          P(H, o);
+        })) {
+          var d = _(g, y + 1), m = d[0], T = d[1];
+          try {
+            E.pushState(m, "", T);
+          } catch {
+            j.location.assign(T);
+          }
+          $(u);
+        }
+      }, "n"), replace: /* @__PURE__ */ r(function P(H, o) {
+        var u = e.Action.Replace, g = Y(H, o);
+        if (V(u, g, function() {
+          P(H, o);
+        })) {
+          var d = _(g, y), m = d[0], T = d[1];
+          E.replaceState(m, "", T), $(u);
+        }
+      }, "n"), go: w, back: /* @__PURE__ */ r(function() {
+        w(-1);
+      }, "back"), forward: /* @__PURE__ */ r(function() {
+        w(1);
+      }, "forward"), listen: /* @__PURE__ */ r(function(P) {
+        return N.push(P);
+      }, "listen"), block: /* @__PURE__ */ r(function(P) {
+        var H = I.push(P);
+        return I.length === 1 && j.addEventListener(n, z), function() {
+          H(), I.length || j.removeEventListener(n, z);
+        };
+      }, "block") };
+    }, e.createMemoryHistory = function(x) {
+      x === void 0 && (x = {});
+      var O = x, j = O.initialEntries, E = j === void 0 ? ["/"] : j, L = O.initialIndex, s = E.map(function(_) {
+        return t({ pathname: "/", search: "", hash: "", state: null, key: U() }, typeof _ == "string" ? F(_) : _);
+      }), i = v(L ?? s.length - 1, 0, s.length - 1), h = e.Action.Pop, c = s[i], y = B(), S = B();
+      function N(_, V) {
+        return V === void 0 && (V = null), t({ pathname: c.pathname, search: "", hash: "" }, typeof _ == "string" ? F(_) : _, { state: V, key: U() });
+      }
+      r(N, "m");
+      function I(_, V, $) {
+        return !S.length || (S.call({ action: _, location: V, retry: $ }), !1);
+      }
+      r(I, "b");
+      function W(_, V) {
+        h = _, c = V, y.call({ action: h, location: c });
+      }
+      r(W, "A");
+      function Y(_) {
+        var V = v(i + _, 0, s.length - 1), $ = e.Action.Pop, w = s[V];
+        I($, w, function() {
+          Y(_);
+        }) && (i = V, W($, w));
+      }
+      return r(Y, "P"), { get index() {
+        return i;
+      }, get action() {
+        return h;
+      }, get location() {
+        return c;
+      }, createHref: /* @__PURE__ */ r(function(_) {
+        return typeof _ == "string" ? _ : J(_);
+      }, "createHref"), push: /* @__PURE__ */ r(function _(V, $) {
+        var w = e.Action.Push, P = N(V, $);
+        I(w, P, function() {
+          _(V, $);
+        }) && (i += 1, s.splice(i, s.length, P), W(w, P));
+      }, "n"), replace: /* @__PURE__ */ r(function _(V, $) {
+        var w = e.Action.Replace, P = N(V, $);
+        I(w, P, function() {
+          _(V, $);
+        }) && (s[i] = P, W(w, P));
+      }, "n"), go: Y, back: /* @__PURE__ */ r(function() {
+        Y(-1);
+      }, "back"), forward: /* @__PURE__ */ r(function() {
+        Y(1);
+      }, "forward"), listen: /* @__PURE__ */ r(function(_) {
+        return y.push(_);
+      }, "listen"), block: /* @__PURE__ */ r(function(_) {
+        return S.push(_);
+      }, "block") };
+    }, e.createPath = J, e.parsePath = F, Object.defineProperty(e, "__esModule", { value: !0 });
+  });
+});
+
+// ../node_modules/history/umd/history.development.js
+var fr = ne((Be, cr) => {
+  (function(e, t) {
+    typeof Be == "object" && typeof cr < "u" ? t(Be) : typeof define == "function" && define.amd ? define(["exports"], t) : (e = typeof globalThis <
+    "u" ? globalThis : e || self, t(e.HistoryLibrary = {}));
+  })(Be, function(e) {
+    "use strict";
+    function t() {
+      return t = Object.assign || function(s) {
+        for (var i = 1; i < arguments.length; i++) {
+          var h = arguments[i];
+          for (var c in h)
+            Object.prototype.hasOwnProperty.call(h, c) && (s[c] = h[c]);
+        }
+        return s;
+      }, t.apply(this, arguments);
+    }
+    r(t, "_extends"), e.Action = void 0, function(s) {
+      s.Pop = "POP", s.Push = "PUSH", s.Replace = "REPLACE";
+    }(e.Action || (e.Action = {}));
+    var a = /* @__PURE__ */ r(function(s) {
+      return Object.freeze(s);
+    }, "readOnly");
+    function n(s, i) {
+      if (!s) {
+        typeof console < "u" && console.warn(i);
+        try {
+          throw new Error(i);
+        } catch {
+        }
+      }
+    }
+    r(n, "warning");
+    var l = "beforeunload", v = "hashchange", z = "popstate";
+    function B(s) {
+      s === void 0 && (s = {});
+      var i = s, h = i.window, c = h === void 0 ? document.defaultView : h, y = c.history;
+      function S() {
+        var C = c.location, p = C.pathname, R = C.search, K = C.hash, q = y.state || {};
+        return [q.idx, a({
+          pathname: p,
+          search: R,
+          hash: K,
+          state: q.usr || null,
+          key: q.key || "default"
+        })];
+      }
+      r(S, "getIndexAndLocation");
+      var N = null;
+      function I() {
+        if (N)
+          w.call(N), N = null;
+        else {
+          var C = e.Action.Pop, p = S(), R = p[0], K = p[1];
+          if (w.length)
+            if (R != null) {
+              var q = _ - R;
+              q && (N = {
+                action: C,
+                location: K,
+                retry: /* @__PURE__ */ r(function() {
+                  T(q * -1);
+                }, "retry")
+              }, T(q));
+            } else
+              n(
+                !1,
+                // TODO: Write up a doc that explains our blocking strategy in
+                // detail and link to it here so people can understand better what
+                // is going on and how to avoid it.
+                "You are trying to block a POP navigation to a location that was not created by the history library. The block will fail sil\
+ently in production, but in general you should do all navigation with the history library (instead of using window.history.pushState directl\
+y) to avoid this situation."
+              );
+          else
+            g(C);
+        }
+      }
+      r(I, "handlePop"), c.addEventListener(z, I);
+      var W = e.Action.Pop, Y = S(), _ = Y[0], V = Y[1], $ = O(), w = O();
+      _ == null && (_ = 0, y.replaceState(t({}, y.state, {
+        idx: _
+      }), ""));
+      function P(C) {
+        return typeof C == "string" ? C : E(C);
+      }
+      r(P, "createHref");
+      function H(C, p) {
+        return p === void 0 && (p = null), a(t({
+          pathname: V.pathname,
+          hash: "",
+          search: ""
+        }, typeof C == "string" ? L(C) : C, {
+          state: p,
+          key: j()
+        }));
+      }
+      r(H, "getNextLocation");
+      function o(C, p) {
+        return [{
+          usr: C.state,
+          key: C.key,
+          idx: p
+        }, P(C)];
+      }
+      r(o, "getHistoryStateAndUrl");
+      function u(C, p, R) {
+        return !w.length || (w.call({
+          action: C,
+          location: p,
+          retry: R
+        }), !1);
+      }
+      r(u, "allowTx");
+      function g(C) {
+        W = C;
+        var p = S();
+        _ = p[0], V = p[1], $.call({
+          action: W,
+          location: V
+        });
+      }
+      r(g, "applyTx");
+      function d(C, p) {
+        var R = e.Action.Push, K = H(C, p);
+        function q() {
+          d(C, p);
+        }
+        if (r(q, "retry"), u(R, K, q)) {
+          var Z = o(K, _ + 1), re = Z[0], ae = Z[1];
+          try {
+            y.pushState(re, "", ae);
+          } catch {
+            c.location.assign(ae);
+          }
+          g(R);
+        }
+      }
+      r(d, "push");
+      function m(C, p) {
+        var R = e.Action.Replace, K = H(C, p);
+        function q() {
+          m(C, p);
+        }
+        if (r(q, "retry"), u(R, K, q)) {
+          var Z = o(K, _), re = Z[0], ae = Z[1];
+          y.replaceState(re, "", ae), g(R);
+        }
+      }
+      r(m, "replace");
+      function T(C) {
+        y.go(C);
+      }
+      r(T, "go");
+      var M = {
+        get action() {
+          return W;
+        },
+        get location() {
+          return V;
+        },
+        createHref: P,
+        push: d,
+        replace: m,
+        go: T,
+        back: /* @__PURE__ */ r(function() {
+          T(-1);
+        }, "back"),
+        forward: /* @__PURE__ */ r(function() {
+          T(1);
+        }, "forward"),
+        listen: /* @__PURE__ */ r(function(p) {
+          return $.push(p);
+        }, "listen"),
+        block: /* @__PURE__ */ r(function(p) {
+          var R = w.push(p);
+          return w.length === 1 && c.addEventListener(l, x), function() {
+            R(), w.length || c.removeEventListener(l, x);
+          };
+        }, "block")
+      };
+      return M;
+    }
+    r(B, "createBrowserHistory");
+    function U(s) {
+      s === void 0 && (s = {});
+      var i = s, h = i.window, c = h === void 0 ? document.defaultView : h, y = c.history;
+      function S() {
+        var p = L(c.location.hash.substr(1)), R = p.pathname, K = R === void 0 ? "/" : R, q = p.search, Z = q === void 0 ? "" : q, re = p.hash,
+        ae = re === void 0 ? "" : re, ie = y.state || {};
+        return [ie.idx, a({
+          pathname: K,
+          search: Z,
+          hash: ae,
+          state: ie.usr || null,
+          key: ie.key || "default"
+        })];
+      }
+      r(S, "getIndexAndLocation");
+      var N = null;
+      function I() {
+        if (N)
+          w.call(N), N = null;
+        else {
+          var p = e.Action.Pop, R = S(), K = R[0], q = R[1];
+          if (w.length)
+            if (K != null) {
+              var Z = _ - K;
+              Z && (N = {
+                action: p,
+                location: q,
+                retry: /* @__PURE__ */ r(function() {
+                  M(Z * -1);
+                }, "retry")
+              }, M(Z));
+            } else
+              n(
+                !1,
+                // TODO: Write up a doc that explains our blocking strategy in
+                // detail and link to it here so people can understand better
+                // what is going on and how to avoid it.
+                "You are trying to block a POP navigation to a location that was not created by the history library. The block will fail sil\
+ently in production, but in general you should do all navigation with the history library (instead of using window.history.pushState directl\
+y) to avoid this situation."
+              );
+          else
+            d(p);
+        }
+      }
+      r(I, "handlePop"), c.addEventListener(z, I), c.addEventListener(v, function() {
+        var p = S(), R = p[1];
+        E(R) !== E(V) && I();
+      });
+      var W = e.Action.Pop, Y = S(), _ = Y[0], V = Y[1], $ = O(), w = O();
+      _ == null && (_ = 0, y.replaceState(t({}, y.state, {
+        idx: _
+      }), ""));
+      function P() {
+        var p = document.querySelector("base"), R = "";
+        if (p && p.getAttribute("href")) {
+          var K = c.location.href, q = K.indexOf("#");
+          R = q === -1 ? K : K.slice(0, q);
+        }
+        return R;
+      }
+      r(P, "getBaseHref");
+      function H(p) {
+        return P() + "#" + (typeof p == "string" ? p : E(p));
+      }
+      r(H, "createHref");
+      function o(p, R) {
+        return R === void 0 && (R = null), a(t({
+          pathname: V.pathname,
+          hash: "",
+          search: ""
+        }, typeof p == "string" ? L(p) : p, {
+          state: R,
+          key: j()
+        }));
+      }
+      r(o, "getNextLocation");
+      function u(p, R) {
+        return [{
+          usr: p.state,
+          key: p.key,
+          idx: R
+        }, H(p)];
+      }
+      r(u, "getHistoryStateAndUrl");
+      function g(p, R, K) {
+        return !w.length || (w.call({
+          action: p,
+          location: R,
+          retry: K
+        }), !1);
+      }
+      r(g, "allowTx");
+      function d(p) {
+        W = p;
+        var R = S();
+        _ = R[0], V = R[1], $.call({
+          action: W,
+          location: V
+        });
+      }
+      r(d, "applyTx");
+      function m(p, R) {
+        var K = e.Action.Push, q = o(p, R);
+        function Z() {
+          m(p, R);
+        }
+        if (r(Z, "retry"), n(q.pathname.charAt(0) === "/", "Relative pathnames are not supported in hash history.push(" + JSON.stringify(p) +
+        ")"), g(K, q, Z)) {
+          var re = u(q, _ + 1), ae = re[0], ie = re[1];
+          try {
+            y.pushState(ae, "", ie);
+          } catch {
+            c.location.assign(ie);
+          }
+          d(K);
+        }
+      }
+      r(m, "push");
+      function T(p, R) {
+        var K = e.Action.Replace, q = o(p, R);
+        function Z() {
+          T(p, R);
+        }
+        if (r(Z, "retry"), n(q.pathname.charAt(0) === "/", "Relative pathnames are not supported in hash history.replace(" + JSON.stringify(
+        p) + ")"), g(K, q, Z)) {
+          var re = u(q, _), ae = re[0], ie = re[1];
+          y.replaceState(ae, "", ie), d(K);
+        }
+      }
+      r(T, "replace");
+      function M(p) {
+        y.go(p);
+      }
+      r(M, "go");
+      var C = {
+        get action() {
+          return W;
+        },
+        get location() {
+          return V;
+        },
+        createHref: H,
+        push: m,
+        replace: T,
+        go: M,
+        back: /* @__PURE__ */ r(function() {
+          M(-1);
+        }, "back"),
+        forward: /* @__PURE__ */ r(function() {
+          M(1);
+        }, "forward"),
+        listen: /* @__PURE__ */ r(function(R) {
+          return $.push(R);
+        }, "listen"),
+        block: /* @__PURE__ */ r(function(R) {
+          var K = w.push(R);
+          return w.length === 1 && c.addEventListener(l, x), function() {
+            K(), w.length || c.removeEventListener(l, x);
+          };
+        }, "block")
+      };
+      return C;
+    }
+    r(U, "createHashHistory");
+    function J(s) {
+      s === void 0 && (s = {});
+      var i = s, h = i.initialEntries, c = h === void 0 ? ["/"] : h, y = i.initialIndex, S = c.map(function(d) {
+        var m = a(t({
+          pathname: "/",
+          search: "",
+          hash: "",
+          state: null,
+          key: j()
+        }, typeof d == "string" ? L(d) : d));
+        return n(m.pathname.charAt(0) === "/", "Relative pathnames are not supported in createMemoryHistory({ initialEntries }) (invalid ent\
+ry: " + JSON.stringify(d) + ")"), m;
+      }), N = F(y ?? S.length - 1, 0, S.length - 1), I = e.Action.Pop, W = S[N], Y = O(), _ = O();
+      function V(d) {
+        return typeof d == "string" ? d : E(d);
+      }
+      r(V, "createHref");
+      function $(d, m) {
+        return m === void 0 && (m = null), a(t({
+          pathname: W.pathname,
+          search: "",
+          hash: ""
+        }, typeof d == "string" ? L(d) : d, {
+          state: m,
+          key: j()
+        }));
+      }
+      r($, "getNextLocation");
+      function w(d, m, T) {
+        return !_.length || (_.call({
+          action: d,
+          location: m,
+          retry: T
+        }), !1);
+      }
+      r(w, "allowTx");
+      function P(d, m) {
+        I = d, W = m, Y.call({
+          action: I,
+          location: W
+        });
+      }
+      r(P, "applyTx");
+      function H(d, m) {
+        var T = e.Action.Push, M = $(d, m);
+        function C() {
+          H(d, m);
+        }
+        r(C, "retry"), n(W.pathname.charAt(0) === "/", "Relative pathnames are not supported in memory history.push(" + JSON.stringify(d) + "\
+)"), w(T, M, C) && (N += 1, S.splice(N, S.length, M), P(T, M));
+      }
+      r(H, "push");
+      function o(d, m) {
+        var T = e.Action.Replace, M = $(d, m);
+        function C() {
+          o(d, m);
+        }
+        r(C, "retry"), n(W.pathname.charAt(0) === "/", "Relative pathnames are not supported in memory history.replace(" + JSON.stringify(d) +
+        ")"), w(T, M, C) && (S[N] = M, P(T, M));
+      }
+      r(o, "replace");
+      function u(d) {
+        var m = F(N + d, 0, S.length - 1), T = e.Action.Pop, M = S[m];
+        function C() {
+          u(d);
+        }
+        r(C, "retry"), w(T, M, C) && (N = m, P(T, M));
+      }
+      r(u, "go");
+      var g = {
+        get index() {
+          return N;
+        },
+        get action() {
+          return I;
+        },
+        get location() {
+          return W;
+        },
+        createHref: V,
+        push: H,
+        replace: o,
+        go: u,
+        back: /* @__PURE__ */ r(function() {
+          u(-1);
+        }, "back"),
+        forward: /* @__PURE__ */ r(function() {
+          u(1);
+        }, "forward"),
+        listen: /* @__PURE__ */ r(function(m) {
+          return Y.push(m);
+        }, "listen"),
+        block: /* @__PURE__ */ r(function(m) {
+          return _.push(m);
+        }, "block")
+      };
+      return g;
+    }
+    r(J, "createMemoryHistory");
+    function F(s, i, h) {
+      return Math.min(Math.max(s, i), h);
+    }
+    r(F, "clamp");
+    function x(s) {
+      s.preventDefault(), s.returnValue = "";
+    }
+    r(x, "promptBeforeUnload");
+    function O() {
+      var s = [];
+      return {
+        get length() {
+          return s.length;
+        },
+        push: /* @__PURE__ */ r(function(h) {
+          return s.push(h), function() {
+            s = s.filter(function(c) {
+              return c !== h;
+            });
+          };
+        }, "push"),
+        call: /* @__PURE__ */ r(function(h) {
+          s.forEach(function(c) {
+            return c && c(h);
+          });
+        }, "call")
+      };
+    }
+    r(O, "createEvents");
+    function j() {
+      return Math.random().toString(36).substr(2, 8);
+    }
+    r(j, "createKey");
+    function E(s) {
+      var i = s.pathname, h = i === void 0 ? "/" : i, c = s.search, y = c === void 0 ? "" : c, S = s.hash, N = S === void 0 ? "" : S;
+      return y && y !== "?" && (h += y.charAt(0) === "?" ? y : "?" + y), N && N !== "#" && (h += N.charAt(0) === "#" ? N : "#" + N), h;
+    }
+    r(E, "createPath");
+    function L(s) {
+      var i = {};
+      if (s) {
+        var h = s.indexOf("#");
+        h >= 0 && (i.hash = s.substr(h), s = s.substr(0, h));
+        var c = s.indexOf("?");
+        c >= 0 && (i.search = s.substr(c), s = s.substr(0, c)), s && (i.pathname = s);
+      }
+      return i;
+    }
+    r(L, "parsePath"), e.createBrowserHistory = B, e.createHashHistory = U, e.createMemoryHistory = J, e.createPath = E, e.parsePath = L, Object.
+    defineProperty(e, "__esModule", { value: !0 });
+  });
+});
+
+// ../node_modules/history/main.js
+var Ee = ne((pa, at) => {
+  "use strict";
+  process.env.NODE_ENV === "production" ? at.exports = lr() : at.exports = fr();
+});
+
+// ../node_modules/react-router/umd/react-router.production.min.js
+var pr = ne((De, hr) => {
+  (function(e, t) {
+    typeof De == "object" && typeof hr < "u" ? t(De, require("react"), Ee()) : typeof define == "function" && define.amd ? define(["exports",
+    "react", "history"], t) : t((e = e || self).ReactRouter = {}, e.React, e.HistoryLibrary);
+  })(De, function(e, t, a) {
+    "use strict";
+    function n(o, u) {
+      if (!o) throw new Error(u);
+    }
+    r(n, "a");
+    let l = t.createContext(null), v = t.createContext(null), z = t.createContext({ outlet: null, matches: [] });
+    function B(o) {
+      return j();
+    }
+    r(B, "s");
+    function U(o) {
+      n(!1);
+    }
+    r(U, "o");
+    function J(o) {
+      let { basename: u = "/", children: g = null, location: d, navigationType: m = a.Action.Pop, navigator: T, static: M = !1 } = o;
+      F() && n(!1);
+      let C = w(u), p = t.useMemo(() => ({ basename: C, navigator: T, static: M }), [C, T, M]);
+      typeof d == "string" && (d = a.parsePath(d));
+      let { pathname: R = "/", search: K = "", hash: q = "", state: Z = null, key: re = "default" } = d, ae = t.useMemo(() => {
+        let ie = V(R, C);
+        return ie == null ? null : { pathname: ie, search: K, hash: q, state: Z, key: re };
+      }, [C, R, K, q, Z, re]);
+      return ae == null ? null : t.createElement(l.Provider, { value: p }, t.createElement(v.Provider, { children: g, value: { location: ae,
+      navigationType: m } }));
+    }
+    r(J, "u");
+    function F() {
+      return t.useContext(v) != null;
+    }
+    r(F, "c");
+    function x() {
+      return F() || n(!1), t.useContext(v).location;
+    }
+    r(x, "h");
+    function O() {
+      F() || n(!1);
+      let { basename: o, navigator: u } = t.useContext(l), { matches: g } = t.useContext(z), { pathname: d } = x(), m = JSON.stringify(g.map(
+      (M) => M.pathnameBase)), T = t.useRef(!1);
+      return t.useEffect(() => {
+        T.current = !0;
+      }), t.useCallback(function(M, C) {
+        if (C === void 0 && (C = {}), !T.current) return;
+        if (typeof M == "number") return void u.go(M);
+        let p = _(M, JSON.parse(m), d);
+        o !== "/" && (p.pathname = $([o, p.pathname])), (C.replace ? u.replace : u.push)(p, C.state);
+      }, [o, u, m, d]);
+    }
+    r(O, "p");
+    function j() {
+      return t.useContext(z).outlet;
+    }
+    r(j, "f");
+    function E(o) {
+      let { matches: u } = t.useContext(z), { pathname: g } = x(), d = JSON.stringify(u.map((m) => m.pathnameBase));
+      return t.useMemo(() => _(o, JSON.parse(d), g), [o, d, g]);
+    }
+    r(E, "m");
+    function L(o, u) {
+      F() || n(!1);
+      let g, { matches: d } = t.useContext(z), m = d[d.length - 1], T = m ? m.params : {}, M = (m && m.pathname, m ? m.pathnameBase : "/"), C = (m &&
+      m.route, x());
+      if (u) {
+        var p;
+        let q = typeof u == "string" ? a.parsePath(u) : u;
+        M === "/" || (p = q.pathname) != null && p.startsWith(M) || n(!1), g = q;
+      } else g = C;
+      let R = g.pathname || "/", K = i(o, { pathname: M === "/" ? R : R.slice(M.length) || "/" });
+      return I(K && K.map((q) => Object.assign({}, q, { params: Object.assign({}, T, q.params), pathname: $([M, q.pathname]), pathnameBase: q.
+      pathnameBase === "/" ? M : $([M, q.pathnameBase]) })), d);
+    }
+    r(L, "d");
+    function s(o) {
+      let u = [];
+      return t.Children.forEach(o, (g) => {
+        if (!t.isValidElement(g)) return;
+        if (g.type === t.Fragment) return void u.push.apply(u, s(g.props.children));
+        g.type !== U && n(!1);
+        let d = { caseSensitive: g.props.caseSensitive, element: g.props.element, index: g.props.index, path: g.props.path };
+        g.props.children && (d.children = s(g.props.children)), u.push(d);
+      }), u;
+    }
+    r(s, "g");
+    function i(o, u, g) {
+      g === void 0 && (g = "/");
+      let d = V((typeof u == "string" ? a.parsePath(u) : u).pathname || "/", g);
+      if (d == null) return null;
+      let m = h(o);
+      (function(M) {
+        M.sort((C, p) => C.score !== p.score ? p.score - C.score : function(R, K) {
+          return R.length === K.length && R.slice(0, -1).every((q, Z) => q === K[Z]) ? R[R.length - 1] - K[K.length - 1] : 0;
+        }(C.routesMeta.map((R) => R.childrenIndex), p.routesMeta.map((R) => R.childrenIndex)));
+      })(m);
+      let T = null;
+      for (let M = 0; T == null && M < m.length; ++M) T = N(m[M], o, d);
+      return T;
+    }
+    r(i, "v");
+    function h(o, u, g, d) {
+      return u === void 0 && (u = []), g === void 0 && (g = []), d === void 0 && (d = ""), o.forEach((m, T) => {
+        let M = { relativePath: m.path || "", caseSensitive: m.caseSensitive === !0, childrenIndex: T };
+        M.relativePath.startsWith("/") && (M.relativePath.startsWith(d) || n(!1), M.relativePath = M.relativePath.slice(d.length));
+        let C = $([d, M.relativePath]), p = g.concat(M);
+        m.children && m.children.length > 0 && (m.index === !0 && n(!1), h(m.children, u, p, C)), (m.path != null || m.index) && u.push({ path: C,
+        score: S(C, m.index), routesMeta: p });
+      }), u;
+    }
+    r(h, "y");
+    let c = /^:\w+$/, y = /* @__PURE__ */ r((o) => o === "*", "C");
+    function S(o, u) {
+      let g = o.split("/"), d = g.length;
+      return g.some(y) && (d += -2), u && (d += 2), g.filter((m) => !y(m)).reduce((m, T) => m + (c.test(T) ? 3 : T === "" ? 1 : 10), d);
+    }
+    r(S, "P");
+    function N(o, u, g) {
+      let d = u, { routesMeta: m } = o, T = {}, M = "/", C = [];
+      for (let p = 0; p < m.length; ++p) {
+        let R = m[p], K = p === m.length - 1, q = M === "/" ? g : g.slice(M.length) || "/", Z = W({ path: R.relativePath, caseSensitive: R.caseSensitive,
+        end: K }, q);
+        if (!Z) return null;
+        Object.assign(T, Z.params);
+        let re = d[R.childrenIndex];
+        C.push({ params: T, pathname: $([M, Z.pathname]), pathnameBase: $([M, Z.pathnameBase]), route: re }), Z.pathnameBase !== "/" && (M =
+        $([M, Z.pathnameBase])), d = re.children;
+      }
+      return C;
+    }
+    r(N, "E");
+    function I(o, u) {
+      return u === void 0 && (u = []), o == null ? null : o.reduceRight((g, d, m) => t.createElement(z.Provider, { children: d.route.element !==
+      void 0 ? d.route.element : t.createElement(B, null), value: { outlet: g, matches: u.concat(o.slice(0, m + 1)) } }), null);
+    }
+    r(I, "R");
+    function W(o, u) {
+      typeof o == "string" && (o = { path: o, caseSensitive: !1, end: !0 });
+      let [g, d] = function(p, R, K) {
+        R === void 0 && (R = !1), K === void 0 && (K = !0);
+        let q = [], Z = "^" + p.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^$?{}|()[\]]/g, "\\$&").replace(/:(\w+)/g, (re, ae) => (q.
+        push(ae), "([^\\/]+)"));
+        return p.endsWith("*") ? (q.push("*"), Z += p === "*" || p === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$") : Z += K ? "\\/*$" : "(?:\\b|$)",
+        [new RegExp(Z, R ? void 0 : "i"), q];
+      }(o.path, o.caseSensitive, o.end), m = u.match(g);
+      if (!m) return null;
+      let T = m[0], M = T.replace(/(.)\/+$/, "$1"), C = m.slice(1);
+      return { params: d.reduce((p, R, K) => {
+        if (R === "*") {
+          let q = C[K] || "";
+          M = T.slice(0, T.length - q.length).replace(/(.)\/+$/, "$1");
+        }
+        return p[R] = function(q, Z) {
+          try {
+            return decodeURIComponent(q);
+          } catch {
+            return q;
+          }
+        }(C[K] || ""), p;
+      }, {}), pathname: T, pathnameBase: M, pattern: o };
+    }
+    r(W, "S");
+    function Y(o, u) {
+      u === void 0 && (u = "/");
+      let { pathname: g, search: d = "", hash: m = "" } = typeof o == "string" ? a.parsePath(o) : o;
+      return { pathname: g ? g.startsWith("/") ? g : function(M, C) {
+        let p = C.replace(/\/+$/, "").split("/");
+        return M.split("/").forEach((R) => {
+          R === ".." ? p.length > 1 && p.pop() : R !== "." && p.push(R);
+        }), p.length > 1 ? p.join("/") : "/";
+      }(g, u) : u, search: P(d), hash: H(m) };
+    }
+    r(Y, "b");
+    function _(o, u, g) {
+      let d, m = typeof o == "string" ? a.parsePath(o) : o, T = o === "" || m.pathname === "" ? "/" : m.pathname;
+      if (T == null) d = g;
+      else {
+        let C = u.length - 1;
+        if (T.startsWith("..")) {
+          let p = T.split("/");
+          for (; p[0] === ".."; ) p.shift(), C -= 1;
+          m.pathname = p.join("/");
+        }
+        d = C >= 0 ? u[C] : "/";
+      }
+      let M = Y(m, d);
+      return T && T !== "/" && T.endsWith("/") && !M.pathname.endsWith("/") && (M.pathname += "/"), M;
+    }
+    r(_, "$");
+    function V(o, u) {
+      if (u === "/") return o;
+      if (!o.toLowerCase().startsWith(u.toLowerCase())) return null;
+      let g = o.charAt(u.length);
+      return g && g !== "/" ? null : o.slice(u.length) || "/";
+    }
+    r(V, "M");
+    let $ = /* @__PURE__ */ r((o) => o.join("/").replace(/\/\/+/g, "/"), "W"), w = /* @__PURE__ */ r((o) => o.replace(/\/+$/, "").replace(/^\/*/,
+    "/"), "B"), P = /* @__PURE__ */ r((o) => o && o !== "?" ? o.startsWith("?") ? o : "?" + o : "", "N"), H = /* @__PURE__ */ r((o) => o && o !==
+    "#" ? o.startsWith("#") ? o : "#" + o : "", "O");
+    e.MemoryRouter = function(o) {
+      let { basename: u, children: g, initialEntries: d, initialIndex: m } = o, T = t.useRef();
+      T.current == null && (T.current = a.createMemoryHistory({ initialEntries: d, initialIndex: m }));
+      let M = T.current, [C, p] = t.useState({ action: M.action, location: M.location });
+      return t.useLayoutEffect(() => M.listen(p), [M]), t.createElement(J, { basename: u, children: g, location: C.location, navigationType: C.
+      action, navigator: M });
+    }, e.Navigate = function(o) {
+      let { to: u, replace: g, state: d } = o;
+      F() || n(!1);
+      let m = O();
+      return t.useEffect(() => {
+        m(u, { replace: g, state: d });
+      }), null;
+    }, e.Outlet = B, e.Route = U, e.Router = J, e.Routes = function(o) {
+      let { children: u, location: g } = o;
+      return L(s(u), g);
+    }, e.UNSAFE_LocationContext = v, e.UNSAFE_NavigationContext = l, e.UNSAFE_RouteContext = z, e.createRoutesFromChildren = s, e.generatePath =
+    function(o, u) {
+      return u === void 0 && (u = {}), o.replace(/:(\w+)/g, (g, d) => (u[d] == null && n(!1), u[d])).replace(/\/*\*$/, (g) => u["*"] == null ?
+      "" : u["*"].replace(/^\/*/, "/"));
+    }, e.matchPath = W, e.matchRoutes = i, e.renderMatches = function(o) {
+      return I(o);
+    }, e.resolvePath = Y, e.useHref = function(o) {
+      F() || n(!1);
+      let { basename: u, navigator: g } = t.useContext(l), { hash: d, pathname: m, search: T } = E(o), M = m;
+      if (u !== "/") {
+        let C = function(R) {
+          return R === "" || R.pathname === "" ? "/" : typeof R == "string" ? a.parsePath(R).pathname : R.pathname;
+        }(o), p = C != null && C.endsWith("/");
+        M = m === "/" ? u + (p ? "/" : "") : $([u, m]);
+      }
+      return g.createHref({ pathname: M, search: T, hash: d });
+    }, e.useInRouterContext = F, e.useLocation = x, e.useMatch = function(o) {
+      return F() || n(!1), W(o, x().pathname);
+    }, e.useNavigate = O, e.useNavigationType = function() {
+      return t.useContext(v).navigationType;
+    }, e.useOutlet = j, e.useParams = function() {
+      let { matches: o } = t.useContext(z), u = o[o.length - 1];
+      return u ? u.params : {};
+    }, e.useResolvedPath = E, e.useRoutes = L, Object.defineProperty(e, "__esModule", { value: !0 });
+  });
+});
+
+// ../node_modules/react-router/umd/react-router.development.js
+var mr = ne((We, dr) => {
+  (function(e, t) {
+    typeof We == "object" && typeof dr < "u" ? t(We, require("react"), Ee()) : typeof define == "function" && define.amd ? define(["exports",
+    "react", "history"], t) : (e = e || self, t(e.ReactRouter = {}, e.React, e.HistoryLibrary));
+  })(We, function(e, t, a) {
+    "use strict";
+    function n(f, b) {
+      if (!f) throw new Error(b);
+    }
+    r(n, "invariant");
+    function l(f, b) {
+      if (!f) {
+        typeof console < "u" && console.warn(b);
+        try {
+          throw new Error(b);
+        } catch {
+        }
+      }
+    }
+    r(l, "warning");
+    let v = {};
+    function z(f, b, A) {
+      !b && !v[f] && (v[f] = !0, l(!1, A));
+    }
+    r(z, "warningOnce");
+    let B = /* @__PURE__ */ t.createContext(null);
+    B.displayName = "Navigation";
+    let U = /* @__PURE__ */ t.createContext(null);
+    U.displayName = "Location";
+    let J = /* @__PURE__ */ t.createContext({
+      outlet: null,
+      matches: []
+    });
+    J.displayName = "Route";
+    function F(f) {
+      let {
+        basename: b,
+        children: A,
+        initialEntries: k,
+        initialIndex: D
+      } = f, G = t.useRef();
+      G.current == null && (G.current = a.createMemoryHistory({
+        initialEntries: k,
+        initialIndex: D
+      }));
+      let Q = G.current, [X, ee] = t.useState({
+        action: Q.action,
+        location: Q.location
+      });
+      return t.useLayoutEffect(() => Q.listen(ee), [Q]), /* @__PURE__ */ t.createElement(E, {
+        basename: b,
+        children: A,
+        location: X.location,
+        navigationType: X.action,
+        navigator: Q
+      });
+    }
+    r(F, "MemoryRouter");
+    function x(f) {
+      let {
+        to: b,
+        replace: A,
+        state: k
+      } = f;
+      i() || n(
+        !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.
+        "<Navigate> may be used only in the context of a <Router> component."
+      ), l(!t.useContext(B).static, "<Navigate> must not be used on the initial render in a <StaticRouter>. This is a no-op, but you should \
+modify your code so the <Navigate> is only ever rendered in response to some user interaction or state change.");
+      let D = S();
+      return t.useEffect(() => {
+        D(b, {
+          replace: A,
+          state: k
+        });
+      }), null;
+    }
+    r(x, "Navigate");
+    function O(f) {
+      return N();
+    }
+    r(O, "Outlet");
+    function j(f) {
+      n(!1, "A <Route> is only ever to be used as the child of <Routes> element, never rendered directly. Please wrap your <Route> in a <Rou\
+tes>.");
+    }
+    r(j, "Route");
+    function E(f) {
+      let {
+        basename: b = "/",
+        children: A = null,
+        location: k,
+        navigationType: D = a.Action.Pop,
+        navigator: G,
+        static: Q = !1
+      } = f;
+      i() && n(!1, "You cannot render a <Router> inside another <Router>. You should never have more than one in your app.");
+      let X = Ar(b), ee = t.useMemo(() => ({
+        basename: X,
+        navigator: G,
+        static: Q
+      }), [X, G, Q]);
+      typeof k == "string" && (k = a.parsePath(k));
+      let {
+        pathname: te = "/",
+        search: ue = "",
+        hash: ce = "",
+        state: se = null,
+        key: le = "default"
+      } = k, oe = t.useMemo(() => {
+        let ct = lt(te, X);
+        return ct == null ? null : {
+          pathname: ct,
+          search: ue,
+          hash: ce,
+          state: se,
+          key: le
+        };
+      }, [X, te, ue, ce, se, le]);
+      return l(oe != null, '<Router basename="' + X + '"> is not able to match the URL ' + ('"' + te + ue + ce + '" because it does not star\
+t with the ') + "basename, so the <Router> won't render anything."), oe == null ? null : /* @__PURE__ */ t.createElement(B.Provider, {
+        value: ee
+      }, /* @__PURE__ */ t.createElement(U.Provider, {
+        children: A,
+        value: {
+          location: oe,
+          navigationType: D
+        }
+      }));
+    }
+    r(E, "Router");
+    function L(f) {
+      let {
+        children: b,
+        location: A
+      } = f;
+      return Y(_(b), A);
+    }
+    r(L, "Routes");
+    function s(f) {
+      i() || n(
+        !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."
+      );
+      let {
+        basename: b,
+        navigator: A
+      } = t.useContext(B), {
+        hash: k,
+        pathname: D,
+        search: G
+      } = W(f), Q = D;
+      if (b !== "/") {
+        let X = Rr(f), ee = X != null && X.endsWith("/");
+        Q = D === "/" ? b + (ee ? "/" : "") : ve([b, D]);
+      }
+      return A.createHref({
+        pathname: Q,
+        search: G,
+        hash: k
+      });
+    }
+    r(s, "useHref");
+    function i() {
+      return t.useContext(U) != null;
+    }
+    r(i, "useInRouterContext");
+    function h() {
+      return i() || n(
+        !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."
+      ), t.useContext(U).location;
+    }
+    r(h, "useLocation");
+    function c() {
+      return t.useContext(U).navigationType;
+    }
+    r(c, "useNavigationType");
+    function y(f) {
+      return i() || n(
+        !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.
+        "useMatch() may be used only in the context of a <Router> component."
+      ), q(f, h().pathname);
+    }
+    r(y, "useMatch");
+    function S() {
+      i() || n(
+        !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."
+      );
+      let {
+        basename: f,
+        navigator: b
+      } = t.useContext(B), {
+        matches: A
+      } = t.useContext(J), {
+        pathname: k
+      } = h(), D = JSON.stringify(A.map((X) => X.pathnameBase)), G = t.useRef(!1);
+      return t.useEffect(() => {
+        G.current = !0;
+      }), t.useCallback(function(X, ee) {
+        if (ee === void 0 && (ee = {}), l(G.current, "You should call navigate() in a React.useEffect(), not when your component is first re\
+ndered."), !G.current) return;
+        if (typeof X == "number") {
+          b.go(X);
+          return;
+        }
+        let te = $e(X, JSON.parse(D), k);
+        f !== "/" && (te.pathname = ve([f, te.pathname])), (ee.replace ? b.replace : b.push)(te, ee.state);
+      }, [f, b, D, k]);
+    }
+    r(S, "useNavigate");
+    function N() {
+      return t.useContext(J).outlet;
+    }
+    r(N, "useOutlet");
+    function I() {
+      let {
+        matches: f
+      } = t.useContext(J), b = f[f.length - 1];
+      return b ? b.params : {};
+    }
+    r(I, "useParams");
+    function W(f) {
+      let {
+        matches: b
+      } = t.useContext(J), {
+        pathname: A
+      } = h(), k = JSON.stringify(b.map((D) => D.pathnameBase));
+      return t.useMemo(() => $e(f, JSON.parse(k), A), [f, k, A]);
+    }
+    r(W, "useResolvedPath");
+    function Y(f, b) {
+      i() || n(
+        !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."
+      );
+      let {
+        matches: A
+      } = t.useContext(J), k = A[A.length - 1], D = k ? k.params : {}, G = k ? k.pathname : "/", Q = k ? k.pathnameBase : "/", X = k && k.route;
+      {
+        let oe = X && X.path || "";
+        z(G, !X || oe.endsWith("*"), "You rendered descendant <Routes> (or called `useRoutes()`) at " + ('"' + G + '" (under <Route path="' +
+        oe + '">) 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="' + oe + '"> to <Route ') + ('path="' + oe + '/*">.'));
+      }
+      let ee = h(), te;
+      if (b) {
+        var ue;
+        let oe = typeof b == "string" ? a.parsePath(b) : b;
+        Q === "/" || (ue = oe.pathname) != null && ue.startsWith(Q) || n(!1, "When overriding the location using `<Routes location>` or `use\
+Routes(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 "' + Q + '" ') + ('but pathname "' + oe.pathname + '" was given in the `location` prop.')), te = oe;
+      } else
+        te = ee;
+      let ce = te.pathname || "/", se = Q === "/" ? ce : ce.slice(Q.length) || "/", le = $(f, {
+        pathname: se
+      });
+      return l(X || le != null, 'No routes matched location "' + te.pathname + te.search + te.hash + '" '), l(le == null || le[le.length - 1].
+      route.element !== void 0, 'Matched leaf route at location "' + te.pathname + te.search + te.hash + '" does not have an element. This m\
+eans it will render an <Outlet /> with a null value by default resulting in an "empty" page.'), K(le && le.map((oe) => Object.assign({}, oe,
+      {
+        params: Object.assign({}, D, oe.params),
+        pathname: ve([Q, oe.pathname]),
+        pathnameBase: oe.pathnameBase === "/" ? Q : ve([Q, oe.pathnameBase])
+      })), A);
+    }
+    r(Y, "useRoutes");
+    function _(f) {
+      let b = [];
+      return t.Children.forEach(f, (A) => {
+        if (!/* @__PURE__ */ t.isValidElement(A))
+          return;
+        if (A.type === t.Fragment) {
+          b.push.apply(b, _(A.props.children));
+          return;
+        }
+        A.type !== j && n(!1, "[" + (typeof A.type == "string" ? A.type : A.type.name) + "] is not a <Route> component. All component childr\
+en of <Routes> must be a <Route> or <React.Fragment>");
+        let k = {
+          caseSensitive: A.props.caseSensitive,
+          element: A.props.element,
+          index: A.props.index,
+          path: A.props.path
+        };
+        A.props.children && (k.children = _(A.props.children)), b.push(k);
+      }), b;
+    }
+    r(_, "createRoutesFromChildren");
+    function V(f, b) {
+      return b === void 0 && (b = {}), f.replace(/:(\w+)/g, (A, k) => (b[k] == null && n(!1, 'Missing ":' + k + '" param'), b[k])).replace(/\/*\*$/,
+      (A) => b["*"] == null ? "" : b["*"].replace(/^\/*/, "/"));
+    }
+    r(V, "generatePath");
+    function $(f, b, A) {
+      A === void 0 && (A = "/");
+      let k = typeof b == "string" ? a.parsePath(b) : b, D = lt(k.pathname || "/", A);
+      if (D == null)
+        return null;
+      let G = w(f);
+      P(G);
+      let Q = null;
+      for (let X = 0; Q == null && X < G.length; ++X)
+        Q = p(G[X], f, D);
+      return Q;
+    }
+    r($, "matchRoutes");
+    function w(f, b, A, k) {
+      return b === void 0 && (b = []), A === void 0 && (A = []), k === void 0 && (k = ""), f.forEach((D, G) => {
+        let Q = {
+          relativePath: D.path || "",
+          caseSensitive: D.caseSensitive === !0,
+          childrenIndex: G
+        };
+        Q.relativePath.startsWith("/") && (Q.relativePath.startsWith(k) || n(!1, 'Absolute route path "' + Q.relativePath + '" nested under \
+path ' + ('"' + k + '" is not valid. An absolute child route path ') + "must start with the combined path of all its parent routes."), Q.relativePath =
+        Q.relativePath.slice(k.length));
+        let X = ve([k, Q.relativePath]), ee = A.concat(Q);
+        D.children && D.children.length > 0 && (D.index === !0 && n(!1, "Index routes must not have child routes. Please remove " + ('all ch\
+ild routes from route path "' + X + '".')), w(D.children, b, ee, X)), !(D.path == null && !D.index) && b.push({
+          path: X,
+          score: M(X, D.index),
+          routesMeta: ee
+        });
+      }), b;
+    }
+    r(w, "flattenRoutes");
+    function P(f) {
+      f.sort((b, A) => b.score !== A.score ? A.score - b.score : C(b.routesMeta.map((k) => k.childrenIndex), A.routesMeta.map((k) => k.childrenIndex)));
+    }
+    r(P, "rankRouteBranches");
+    let H = /^:\w+$/, o = 3, u = 2, g = 1, d = 10, m = -2, T = /* @__PURE__ */ r((f) => f === "*", "isSplat");
+    function M(f, b) {
+      let A = f.split("/"), k = A.length;
+      return A.some(T) && (k += m), b && (k += u), A.filter((D) => !T(D)).reduce((D, G) => D + (H.test(G) ? o : G === "" ? g : d), k);
+    }
+    r(M, "computeScore");
+    function C(f, b) {
+      return f.length === b.length && f.slice(0, -1).every((k, D) => k === b[D]) ? (
+        // 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.
+        f[f.length - 1] - b[b.length - 1]
+      ) : (
+        // Otherwise, it doesn't really make sense to rank non-siblings by index,
+        // so they sort equally.
+        0
+      );
+    }
+    r(C, "compareIndexes");
+    function p(f, b, A) {
+      let k = b, {
+        routesMeta: D
+      } = f, G = {}, Q = "/", X = [];
+      for (let ee = 0; ee < D.length; ++ee) {
+        let te = D[ee], ue = ee === D.length - 1, ce = Q === "/" ? A : A.slice(Q.length) || "/", se = q({
+          path: te.relativePath,
+          caseSensitive: te.caseSensitive,
+          end: ue
+        }, ce);
+        if (!se) return null;
+        Object.assign(G, se.params);
+        let le = k[te.childrenIndex];
+        X.push({
+          params: G,
+          pathname: ve([Q, se.pathname]),
+          pathnameBase: ve([Q, se.pathnameBase]),
+          route: le
+        }), se.pathnameBase !== "/" && (Q = ve([Q, se.pathnameBase])), k = le.children;
+      }
+      return X;
+    }
+    r(p, "matchRouteBranch");
+    function R(f) {
+      return K(f);
+    }
+    r(R, "renderMatches");
+    function K(f, b) {
+      return b === void 0 && (b = []), f == null ? null : f.reduceRight((A, k, D) => /* @__PURE__ */ t.createElement(J.Provider, {
+        children: k.route.element !== void 0 ? k.route.element : /* @__PURE__ */ t.createElement(O, null),
+        value: {
+          outlet: A,
+          matches: b.concat(f.slice(0, D + 1))
+        }
+      }), null);
+    }
+    r(K, "_renderMatches");
+    function q(f, b) {
+      typeof f == "string" && (f = {
+        path: f,
+        caseSensitive: !1,
+        end: !0
+      });
+      let [A, k] = Z(f.path, f.caseSensitive, f.end), D = b.match(A);
+      if (!D) return null;
+      let G = D[0], Q = G.replace(/(.)\/+$/, "$1"), X = D.slice(1);
+      return {
+        params: k.reduce((te, ue, ce) => {
+          if (ue === "*") {
+            let se = X[ce] || "";
+            Q = G.slice(0, G.length - se.length).replace(/(.)\/+$/, "$1");
+          }
+          return te[ue] = re(X[ce] || "", ue), te;
+        }, {}),
+        pathname: G,
+        pathnameBase: Q,
+        pattern: f
+      };
+    }
+    r(q, "matchPath");
+    function Z(f, b, A) {
+      b === void 0 && (b = !1), A === void 0 && (A = !0), l(f === "*" || !f.endsWith("*") || f.endsWith("/*"), 'Route path "' + f + '" will \
+be treated as if it were ' + ('"' + f.replace(/\*$/, "/*") + '" because the `*` character must ') + "always follow a `/` in the pattern. To \
+get rid of this warning, " + ('please change the route path to "' + f.replace(/\*$/, "/*") + '".'));
+      let k = [], D = "^" + f.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^$?{}|()[\]]/g, "\\$&").replace(/:(\w+)/g, (Q, X) => (k.
+      push(X), "([^\\/]+)"));
+      return f.endsWith("*") ? (k.push("*"), D += f === "*" || f === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$") : D += A ? "\\/*$" : (
+        // Otherwise, at least match a word boundary. This restricts parent
+        // routes to matching only their own words and nothing more, e.g. parent
+        // route "/home" should not match "/home2".
+        "(?:\\b|$)"
+      ), [new RegExp(D, b ? void 0 : "i"), k];
+    }
+    r(Z, "compilePath");
+    function re(f, b) {
+      try {
+        return decodeURIComponent(f);
+      } catch (A) {
+        return l(!1, 'The value for the URL param "' + b + '" will not be decoded because' + (' the string "' + f + '" is a malformed URL se\
+gment. This is probably') + (" due to a bad percent encoding (" + A + ").")), f;
+      }
+    }
+    r(re, "safelyDecodeURIComponent");
+    function ae(f, b) {
+      b === void 0 && (b = "/");
+      let {
+        pathname: A,
+        search: k = "",
+        hash: D = ""
+      } = typeof f == "string" ? a.parsePath(f) : f;
+      return {
+        pathname: A ? A.startsWith("/") ? A : ie(A, b) : b,
+        search: Er(k),
+        hash: Cr(D)
+      };
+    }
+    r(ae, "resolvePath");
+    function ie(f, b) {
+      let A = b.replace(/\/+$/, "").split("/");
+      return f.split("/").forEach((D) => {
+        D === ".." ? A.length > 1 && A.pop() : D !== "." && A.push(D);
+      }), A.length > 1 ? A.join("/") : "/";
+    }
+    r(ie, "resolvePathname");
+    function $e(f, b, A) {
+      let k = typeof f == "string" ? a.parsePath(f) : f, D = f === "" || k.pathname === "" ? "/" : k.pathname, G;
+      if (D == null)
+        G = A;
+      else {
+        let X = b.length - 1;
+        if (D.startsWith("..")) {
+          let ee = D.split("/");
+          for (; ee[0] === ".."; )
+            ee.shift(), X -= 1;
+          k.pathname = ee.join("/");
+        }
+        G = X >= 0 ? b[X] : "/";
+      }
+      let Q = ae(k, G);
+      return D && D !== "/" && D.endsWith("/") && !Q.pathname.endsWith("/") && (Q.pathname += "/"), Q;
+    }
+    r($e, "resolveTo");
+    function Rr(f) {
+      return f === "" || f.pathname === "" ? "/" : typeof f == "string" ? a.parsePath(f).pathname : f.pathname;
+    }
+    r(Rr, "getToPathname");
+    function lt(f, b) {
+      if (b === "/") return f;
+      if (!f.toLowerCase().startsWith(b.toLowerCase()))
+        return null;
+      let A = f.charAt(b.length);
+      return A && A !== "/" ? null : f.slice(b.length) || "/";
+    }
+    r(lt, "stripBasename");
+    let ve = /* @__PURE__ */ r((f) => f.join("/").replace(/\/\/+/g, "/"), "joinPaths"), Ar = /* @__PURE__ */ r((f) => f.replace(/\/+$/, "").
+    replace(/^\/*/, "/"), "normalizePathname"), Er = /* @__PURE__ */ r((f) => !f || f === "?" ? "" : f.startsWith("?") ? f : "?" + f, "norma\
+lizeSearch"), Cr = /* @__PURE__ */ r((f) => !f || f === "#" ? "" : f.startsWith("#") ? f : "#" + f, "normalizeHash");
+    e.MemoryRouter = F, e.Navigate = x, e.Outlet = O, e.Route = j, e.Router = E, e.Routes = L, e.UNSAFE_LocationContext = U, e.UNSAFE_NavigationContext =
+    B, e.UNSAFE_RouteContext = J, e.createRoutesFromChildren = _, e.generatePath = V, e.matchPath = q, e.matchRoutes = $, e.renderMatches = R,
+    e.resolvePath = ae, e.useHref = s, e.useInRouterContext = i, e.useLocation = h, e.useMatch = y, e.useNavigate = S, e.useNavigationType =
+    c, e.useOutlet = N, e.useParams = I, e.useResolvedPath = W, e.useRoutes = Y, Object.defineProperty(e, "__esModule", { value: !0 });
+  });
+});
+
+// ../node_modules/react-router/main.js
+var ot = ne((ga, gr) => {
+  "use strict";
+  gr.exports = process.env.NODE_ENV === "production" ? pr() : mr();
+});
+
+// ../node_modules/react-router-dom/umd/react-router-dom.production.min.js
+var vr = ne((He, yr) => {
+  (function(e, t) {
+    typeof He == "object" && typeof yr < "u" ? t(He, require("react"), Ee(), ot()) : typeof define == "function" && define.amd ? define(["ex\
+ports", "react", "history", "react-router"], t) : t((e = e || self).ReactRouterDOM = {}, e.React, e.HistoryLibrary, e.ReactRouter);
+  })(He, function(e, t, a, n) {
+    "use strict";
+    function l() {
+      return l = Object.assign || function(O) {
+        for (var j = 1; j < arguments.length; j++) {
+          var E = arguments[j];
+          for (var L in E) Object.prototype.hasOwnProperty.call(E, L) && (O[L] = E[L]);
+        }
+        return O;
+      }, l.apply(this, arguments);
+    }
+    r(l, "a");
+    function v(O, j) {
+      if (O == null) return {};
+      var E, L, s = {}, i = Object.keys(O);
+      for (L = 0; L < i.length; L++) E = i[L], j.indexOf(E) >= 0 || (s[E] = O[E]);
+      return s;
+    }
+    r(v, "o");
+    let z = ["onClick", "reloadDocument", "replace", "state", "target", "to"], B = ["aria-current", "caseSensitive", "className", "end", "st\
+yle", "to"], U = t.forwardRef(function(O, j) {
+      let { onClick: E, reloadDocument: L, replace: s = !1, state: i, target: h, to: c } = O, y = v(O, z), S = n.useHref(c), N = F(c, { replace: s,
+      state: i, target: h });
+      return t.createElement("a", l({}, y, { href: S, onClick: /* @__PURE__ */ r(function(I) {
+        E && E(I), I.defaultPrevented || L || N(I);
+      }, "onClick"), ref: j, target: h }));
+    }), J = t.forwardRef(function(O, j) {
+      let { "aria-current": E = "page", caseSensitive: L = !1, className: s = "", end: i = !1, style: h, to: c } = O, y = v(O, B), S = n.useLocation(),
+      N = n.useResolvedPath(c), I = S.pathname, W = N.pathname;
+      L || (I = I.toLowerCase(), W = W.toLowerCase());
+      let Y, _ = I === W || !i && I.startsWith(W) && I.charAt(W.length) === "/", V = _ ? E : void 0;
+      Y = typeof s == "function" ? s({ isActive: _ }) : [s, _ ? "active" : null].filter(Boolean).join(" ");
+      let $ = typeof h == "function" ? h({ isActive: _ }) : h;
+      return t.createElement(U, l({}, y, { "aria-current": V, className: Y, ref: j, style: $, to: c }));
+    });
+    function F(O, j) {
+      let { target: E, replace: L, state: s } = j === void 0 ? {} : j, i = n.useNavigate(), h = n.useLocation(), c = n.useResolvedPath(O);
+      return t.useCallback((y) => {
+        if (!(y.button !== 0 || E && E !== "_self" || function(S) {
+          return !!(S.metaKey || S.altKey || S.ctrlKey || S.shiftKey);
+        }(y))) {
+          y.preventDefault();
+          let S = !!L || a.createPath(h) === a.createPath(c);
+          i(O, { replace: S, state: s });
+        }
+      }, [h, i, c, L, s, E, O]);
+    }
+    r(F, "l");
+    function x(O) {
+      return O === void 0 && (O = ""), new URLSearchParams(typeof O == "string" || Array.isArray(O) || O instanceof URLSearchParams ? O : Object.
+      keys(O).reduce((j, E) => {
+        let L = O[E];
+        return j.concat(Array.isArray(L) ? L.map((s) => [E, s]) : [[E, L]]);
+      }, []));
+    }
+    r(x, "f"), Object.defineProperty(e, "MemoryRouter", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.MemoryRouter;
+    }, "get") }), Object.defineProperty(e, "Navigate", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.Navigate;
+    }, "get") }), Object.defineProperty(e, "Outlet", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.Outlet;
+    }, "get") }), Object.defineProperty(e, "Route", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.Route;
+    }, "get") }), Object.defineProperty(e, "Router", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.Router;
+    }, "get") }), Object.defineProperty(e, "Routes", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.Routes;
+    }, "get") }), Object.defineProperty(e, "UNSAFE_LocationContext", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.UNSAFE_LocationContext;
+    }, "get") }), Object.defineProperty(e, "UNSAFE_NavigationContext", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.UNSAFE_NavigationContext;
+    }, "get") }), Object.defineProperty(e, "UNSAFE_RouteContext", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.UNSAFE_RouteContext;
+    }, "get") }), Object.defineProperty(e, "createRoutesFromChildren", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.createRoutesFromChildren;
+    }, "get") }), Object.defineProperty(e, "generatePath", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.generatePath;
+    }, "get") }), Object.defineProperty(e, "matchPath", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.matchPath;
+    }, "get") }), Object.defineProperty(e, "matchRoutes", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.matchRoutes;
+    }, "get") }), Object.defineProperty(e, "renderMatches", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.renderMatches;
+    }, "get") }), Object.defineProperty(e, "resolvePath", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.resolvePath;
+    }, "get") }), Object.defineProperty(e, "useHref", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useHref;
+    }, "get") }), Object.defineProperty(e, "useInRouterContext", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useInRouterContext;
+    }, "get") }), Object.defineProperty(e, "useLocation", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useLocation;
+    }, "get") }), Object.defineProperty(e, "useMatch", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useMatch;
+    }, "get") }), Object.defineProperty(e, "useNavigate", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useNavigate;
+    }, "get") }), Object.defineProperty(e, "useNavigationType", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useNavigationType;
+    }, "get") }), Object.defineProperty(e, "useOutlet", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useOutlet;
+    }, "get") }), Object.defineProperty(e, "useParams", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useParams;
+    }, "get") }), Object.defineProperty(e, "useResolvedPath", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useResolvedPath;
+    }, "get") }), Object.defineProperty(e, "useRoutes", { enumerable: !0, get: /* @__PURE__ */ r(function() {
+      return n.useRoutes;
+    }, "get") }), e.BrowserRouter = function(O) {
+      let { basename: j, children: E, window: L } = O, s = t.useRef();
+      s.current == null && (s.current = a.createBrowserHistory({ window: L }));
+      let i = s.current, [h, c] = t.useState({ action: i.action, location: i.location });
+      return t.useLayoutEffect(() => i.listen(c), [i]), t.createElement(n.Router, { basename: j, children: E, location: h.location, navigationType: h.
+      action, navigator: i });
+    }, e.HashRouter = function(O) {
+      let { basename: j, children: E, window: L } = O, s = t.useRef();
+      s.current == null && (s.current = a.createHashHistory({ window: L }));
+      let i = s.current, [h, c] = t.useState({ action: i.action, location: i.location });
+      return t.useLayoutEffect(() => i.listen(c), [i]), t.createElement(n.Router, { basename: j, children: E, location: h.location, navigationType: h.
+      action, navigator: i });
+    }, e.Link = U, e.NavLink = J, e.createSearchParams = x, e.useLinkClickHandler = F, e.useSearchParams = function(O) {
+      let j = t.useRef(x(O)), E = n.useLocation(), L = t.useMemo(() => {
+        let i = x(E.search);
+        for (let h of j.current.keys()) i.has(h) || j.current.getAll(h).forEach((c) => {
+          i.append(h, c);
+        });
+        return i;
+      }, [E.search]), s = n.useNavigate();
+      return [L, t.useCallback((i, h) => {
+        s("?" + x(i), h);
+      }, [s])];
+    }, Object.defineProperty(e, "__esModule", { value: !0 });
+  });
+});
+
+// ../node_modules/react-router-dom/umd/react-router-dom.development.js
+var xr = ne((Fe, br) => {
+  (function(e, t) {
+    typeof Fe == "object" && typeof br < "u" ? t(Fe, require("react"), Ee(), ot()) : typeof define == "function" && define.amd ? define(["ex\
+ports", "react", "history", "react-router"], t) : (e = e || self, t(e.ReactRouterDOM = {}, e.React, e.HistoryLibrary, e.ReactRouter));
+  })(Fe, function(e, t, a, n) {
+    "use strict";
+    function l() {
+      return l = Object.assign || function(i) {
+        for (var h = 1; h < arguments.length; h++) {
+          var c = arguments[h];
+          for (var y in c)
+            Object.prototype.hasOwnProperty.call(c, y) && (i[y] = c[y]);
+        }
+        return i;
+      }, l.apply(this, arguments);
+    }
+    r(l, "_extends");
+    function v(i, h) {
+      if (i == null) return {};
+      var c = {}, y = Object.keys(i), S, N;
+      for (N = 0; N < y.length; N++)
+        S = y[N], !(h.indexOf(S) >= 0) && (c[S] = i[S]);
+      return c;
+    }
+    r(v, "_objectWithoutPropertiesLoose");
+    let z = ["onClick", "reloadDocument", "replace", "state", "target", "to"], B = ["aria-current", "caseSensitive", "className", "end", "st\
+yle", "to"];
+    function U(i, h) {
+      if (!i) {
+        typeof console < "u" && console.warn(h);
+        try {
+          throw new Error(h);
+        } catch {
+        }
+      }
+    }
+    r(U, "warning");
+    function J(i) {
+      let {
+        basename: h,
+        children: c,
+        window: y
+      } = i, S = t.useRef();
+      S.current == null && (S.current = a.createBrowserHistory({
+        window: y
+      }));
+      let N = S.current, [I, W] = t.useState({
+        action: N.action,
+        location: N.location
+      });
+      return t.useLayoutEffect(() => N.listen(W), [N]), /* @__PURE__ */ t.createElement(n.Router, {
+        basename: h,
+        children: c,
+        location: I.location,
+        navigationType: I.action,
+        navigator: N
+      });
+    }
+    r(J, "BrowserRouter");
+    function F(i) {
+      let {
+        basename: h,
+        children: c,
+        window: y
+      } = i, S = t.useRef();
+      S.current == null && (S.current = a.createHashHistory({
+        window: y
+      }));
+      let N = S.current, [I, W] = t.useState({
+        action: N.action,
+        location: N.location
+      });
+      return t.useLayoutEffect(() => N.listen(W), [N]), /* @__PURE__ */ t.createElement(n.Router, {
+        basename: h,
+        children: c,
+        location: I.location,
+        navigationType: I.action,
+        navigator: N
+      });
+    }
+    r(F, "HashRouter");
+    function x(i) {
+      return !!(i.metaKey || i.altKey || i.ctrlKey || i.shiftKey);
+    }
+    r(x, "isModifiedEvent");
+    let O = /* @__PURE__ */ t.forwardRef(/* @__PURE__ */ r(function(h, c) {
+      let {
+        onClick: y,
+        reloadDocument: S,
+        replace: N = !1,
+        state: I,
+        target: W,
+        to: Y
+      } = h, _ = v(h, z), V = n.useHref(Y), $ = E(Y, {
+        replace: N,
+        state: I,
+        target: W
+      });
+      function w(P) {
+        y && y(P), !P.defaultPrevented && !S && $(P);
+      }
+      return r(w, "handleClick"), // eslint-disable-next-line jsx-a11y/anchor-has-content
+      /* @__PURE__ */ t.createElement("a", l({}, _, {
+        href: V,
+        onClick: w,
+        ref: c,
+        target: W
+      }));
+    }, "LinkWithRef"));
+    O.displayName = "Link";
+    let j = /* @__PURE__ */ t.forwardRef(/* @__PURE__ */ r(function(h, c) {
+      let {
+        "aria-current": y = "page",
+        caseSensitive: S = !1,
+        className: N = "",
+        end: I = !1,
+        style: W,
+        to: Y
+      } = h, _ = v(h, B), V = n.useLocation(), $ = n.useResolvedPath(Y), w = V.pathname, P = $.pathname;
+      S || (w = w.toLowerCase(), P = P.toLowerCase());
+      let H = w === P || !I && w.startsWith(P) && w.charAt(P.length) === "/", o = H ? y : void 0, u;
+      typeof N == "function" ? u = N({
+        isActive: H
+      }) : u = [N, H ? "active" : null].filter(Boolean).join(" ");
+      let g = typeof W == "function" ? W({
+        isActive: H
+      }) : W;
+      return /* @__PURE__ */ t.createElement(O, l({}, _, {
+        "aria-current": o,
+        className: u,
+        ref: c,
+        style: g,
+        to: Y
+      }));
+    }, "NavLinkWithRef"));
+    j.displayName = "NavLink";
+    function E(i, h) {
+      let {
+        target: c,
+        replace: y,
+        state: S
+      } = h === void 0 ? {} : h, N = n.useNavigate(), I = n.useLocation(), W = n.useResolvedPath(i);
+      return t.useCallback((Y) => {
+        if (Y.button === 0 && // Ignore everything but left clicks
+        (!c || c === "_self") && // Let browser handle "target=_blank" etc.
+        !x(Y)) {
+          Y.preventDefault();
+          let _ = !!y || a.createPath(I) === a.createPath(W);
+          N(i, {
+            replace: _,
+            state: S
+          });
+        }
+      }, [I, N, W, y, S, c, i]);
+    }
+    r(E, "useLinkClickHandler");
+    function L(i) {
+      U(typeof URLSearchParams < "u", "You cannot use the `useSearchParams` hook in a browser that does not support the URLSearchParams API.\
+ If you need to support Internet Explorer 11, we recommend you load a polyfill such as https://github.com/ungap/url-search-params\n\nIf you're\
+ unsure how to load polyfills, we recommend you check out https://polyfill.io/v3/ which provides some recommendations about how to load poly\
+fills only for users that need them, instead of for every user.");
+      let h = t.useRef(s(i)), c = n.useLocation(), y = t.useMemo(() => {
+        let I = s(c.search);
+        for (let W of h.current.keys())
+          I.has(W) || h.current.getAll(W).forEach((Y) => {
+            I.append(W, Y);
+          });
+        return I;
+      }, [c.search]), S = n.useNavigate(), N = t.useCallback((I, W) => {
+        S("?" + s(I), W);
+      }, [S]);
+      return [y, N];
+    }
+    r(L, "useSearchParams");
+    function s(i) {
+      return i === void 0 && (i = ""), new URLSearchParams(typeof i == "string" || Array.isArray(i) || i instanceof URLSearchParams ? i : Object.
+      keys(i).reduce((h, c) => {
+        let y = i[c];
+        return h.concat(Array.isArray(y) ? y.map((S) => [c, S]) : [[c, y]]);
+      }, []));
+    }
+    r(s, "createSearchParams"), Object.defineProperty(e, "MemoryRouter", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.MemoryRouter;
+      }, "get")
+    }), Object.defineProperty(e, "Navigate", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.Navigate;
+      }, "get")
+    }), Object.defineProperty(e, "Outlet", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.Outlet;
+      }, "get")
+    }), Object.defineProperty(e, "Route", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.Route;
+      }, "get")
+    }), Object.defineProperty(e, "Router", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.Router;
+      }, "get")
+    }), Object.defineProperty(e, "Routes", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.Routes;
+      }, "get")
+    }), Object.defineProperty(e, "UNSAFE_LocationContext", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.UNSAFE_LocationContext;
+      }, "get")
+    }), Object.defineProperty(e, "UNSAFE_NavigationContext", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.UNSAFE_NavigationContext;
+      }, "get")
+    }), Object.defineProperty(e, "UNSAFE_RouteContext", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.UNSAFE_RouteContext;
+      }, "get")
+    }), Object.defineProperty(e, "createRoutesFromChildren", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.createRoutesFromChildren;
+      }, "get")
+    }), Object.defineProperty(e, "generatePath", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.generatePath;
+      }, "get")
+    }), Object.defineProperty(e, "matchPath", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.matchPath;
+      }, "get")
+    }), Object.defineProperty(e, "matchRoutes", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.matchRoutes;
+      }, "get")
+    }), Object.defineProperty(e, "renderMatches", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.renderMatches;
+      }, "get")
+    }), Object.defineProperty(e, "resolvePath", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.resolvePath;
+      }, "get")
+    }), Object.defineProperty(e, "useHref", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useHref;
+      }, "get")
+    }), Object.defineProperty(e, "useInRouterContext", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useInRouterContext;
+      }, "get")
+    }), Object.defineProperty(e, "useLocation", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useLocation;
+      }, "get")
+    }), Object.defineProperty(e, "useMatch", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useMatch;
+      }, "get")
+    }), Object.defineProperty(e, "useNavigate", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useNavigate;
+      }, "get")
+    }), Object.defineProperty(e, "useNavigationType", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useNavigationType;
+      }, "get")
+    }), Object.defineProperty(e, "useOutlet", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useOutlet;
+      }, "get")
+    }), Object.defineProperty(e, "useParams", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useParams;
+      }, "get")
+    }), Object.defineProperty(e, "useResolvedPath", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useResolvedPath;
+      }, "get")
+    }), Object.defineProperty(e, "useRoutes", {
+      enumerable: !0,
+      get: /* @__PURE__ */ r(function() {
+        return n.useRoutes;
+      }, "get")
+    }), e.BrowserRouter = J, e.HashRouter = F, e.Link = O, e.NavLink = j, e.createSearchParams = s, e.useLinkClickHandler = E, e.useSearchParams =
+    L, Object.defineProperty(e, "__esModule", { value: !0 });
+  });
+});
+
+// ../node_modules/react-router-dom/main.js
+var Or = ne((ba, Pr) => {
+  "use strict";
+  Pr.exports = process.env.NODE_ENV === "production" ? vr() : xr();
+});
+
+// src/router/index.ts
+var jn = {};
+kr(jn, {
+  BaseLocationProvider: () => On,
+  DEEPLY_EQUAL: () => Re,
+  Link: () => wr,
+  Location: () => st,
+  LocationProvider: () => Pn,
+  Match: () => ut,
+  Route: () => Sr,
+  buildArgsParam: () => gn,
+  deepDiff: () => Te,
+  getMatch: () => nt,
+  parsePath: () => tt,
+  queryFromLocation: () => rt,
+  stringifyQuery: () => vn,
+  useNavigate: () => xn
+});
+module.exports = Ir(jn);
+
+// src/router/utils.ts
+var ar = require("storybook/internal/client-logger");
+
+// ../node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function me(e) {
+  if (typeof e != "object" || e == null)
+    return !1;
+  if (Object.getPrototypeOf(e) === null)
+    return !0;
+  if (e.toString() !== "[object Object]")
+    return !1;
+  let t = e;
+  for (; Object.getPrototypeOf(t) !== null; )
+    t = Object.getPrototypeOf(t);
+  return Object.getPrototypeOf(e) === t;
+}
+r(me, "isPlainObject");
+
+// ../node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+var ht = "[object RegExp]", pt = "[object String]", dt = "[object Number]", mt = "[object Boolean]", ze = "[object Arguments]", gt = "[objec\
+t Symbol]", yt = "[object Date]", vt = "[object Map]", bt = "[object Set]", xt = "[object Array]", Pt = "[object Function]", Ot = "[object A\
+rrayBuffer]", Ce = "[object Object]", jt = "[object Error]", wt = "[object DataView]", St = "[object Uint8Array]", Rt = "[object Uint8Clampe\
+dArray]", At = "[object Uint16Array]", Et = "[object Uint32Array]", Ct = "[object BigUint64Array]", Nt = "[object Int8Array]", Lt = "[object\
+ Int16Array]", _t = "[object Int32Array]", Mt = "[object BigInt64Array]", Tt = "[object Float32Array]", kt = "[object Float64Array]";
+
+// ../node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+function qe(e) {
+  return Object.getOwnPropertySymbols(e).filter((t) => Object.prototype.propertyIsEnumerable.call(e, t));
+}
+r(qe, "getSymbols");
+
+// ../node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+function Ue(e) {
+  return e == null ? e === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(e);
+}
+r(Ue, "getTag");
+
+// ../node_modules/es-toolkit/dist/predicate/isEqual.mjs
+function Ve(e, t) {
+  if (typeof e == typeof t)
+    switch (typeof e) {
+      case "bigint":
+      case "string":
+      case "boolean":
+      case "symbol":
+      case "undefined":
+        return e === t;
+      case "number":
+        return e === t || Object.is(e, t);
+      case "function":
+        return e === t;
+      case "object":
+        return ge(e, t);
+    }
+  return ge(e, t);
+}
+r(Ve, "isEqual");
+function ge(e, t, a) {
+  if (Object.is(e, t))
+    return !0;
+  let n = Ue(e), l = Ue(t);
+  if (n === ze && (n = Ce), l === ze && (l = Ce), n !== l)
+    return !1;
+  switch (n) {
+    case pt:
+      return e.toString() === t.toString();
+    case dt: {
+      let B = e.valueOf(), U = t.valueOf();
+      return B === U || Number.isNaN(B) && Number.isNaN(U);
+    }
+    case mt:
+    case yt:
+    case gt:
+      return Object.is(e.valueOf(), t.valueOf());
+    case ht:
+      return e.source === t.source && e.flags === t.flags;
+    case Pt:
+      return e === t;
+  }
+  a = a ?? /* @__PURE__ */ new Map();
+  let v = a.get(e), z = a.get(t);
+  if (v != null && z != null)
+    return v === t;
+  a.set(e, t), a.set(t, e);
+  try {
+    switch (n) {
+      case vt: {
+        if (e.size !== t.size)
+          return !1;
+        for (let [B, U] of e.entries())
+          if (!t.has(B) || !ge(U, t.get(B), a))
+            return !1;
+        return !0;
+      }
+      case bt: {
+        if (e.size !== t.size)
+          return !1;
+        let B = Array.from(e.values()), U = Array.from(t.values());
+        for (let J = 0; J < B.length; J++) {
+          let F = B[J], x = U.findIndex((O) => ge(F, O, a));
+          if (x === -1)
+            return !1;
+          U.splice(x, 1);
+        }
+        return !0;
+      }
+      case xt:
+      case St:
+      case Rt:
+      case At:
+      case Et:
+      case Ct:
+      case Nt:
+      case Lt:
+      case _t:
+      case Mt:
+      case Tt:
+      case kt: {
+        if (typeof Buffer < "u" && Buffer.isBuffer(e) !== Buffer.isBuffer(t) || e.length !== t.length)
+          return !1;
+        for (let B = 0; B < e.length; B++)
+          if (!ge(e[B], t[B], a))
+            return !1;
+        return !0;
+      }
+      case Ot:
+        return e.byteLength !== t.byteLength ? !1 : ge(new Uint8Array(e), new Uint8Array(t), a);
+      case wt:
+        return e.byteLength !== t.byteLength || e.byteOffset !== t.byteOffset ? !1 : ge(e.buffer, t.buffer, a);
+      case jt:
+        return e.name === t.name && e.message === t.message;
+      case Ce: {
+        if (!(ge(e.constructor, t.constructor, a) || me(e) && me(t)))
+          return !1;
+        let U = [...Object.keys(e), ...qe(e)], J = [...Object.keys(t), ...qe(t)];
+        if (U.length !== J.length)
+          return !1;
+        for (let F = 0; F < U.length; F++) {
+          let x = U[F], O = e[x];
+          if (!Object.prototype.hasOwnProperty.call(t, x))
+            return !1;
+          let j = t[x];
+          if (!ge(O, j, a))
+            return !1;
+        }
+        return !0;
+      }
+      default:
+        return !1;
+    }
+  } finally {
+    a.delete(e), a.delete(t);
+  }
+}
+r(ge, "areObjectsEqual");
+
+// src/router/utils.ts
+var ke = we($t(), 1), Ae = we(er(), 1), or = we(rr(), 1);
+var hn = /\/([^/]+)\/(?:(.*)_)?([^/]+)?/, tt = (0, ke.default)(1e3)((e) => {
+  let t = {
+    viewMode: void 0,
+    storyId: void 0,
+    refId: void 0
+  };
+  if (e) {
+    let [, a, n, l] = e.toLowerCase().match(hn) || [];
+    a && Object.assign(t, {
+      viewMode: a,
+      storyId: l,
+      refId: n
+    });
+  }
+  return t;
+}), Re = Symbol("Deeply equal"), Te = /* @__PURE__ */ r((e, t) => {
+  if (typeof e != typeof t)
+    return t;
+  if (Ve(e, t))
+    return Re;
+  if (Array.isArray(e) && Array.isArray(t)) {
+    let a = t.reduce((n, l, v) => {
+      let z = Te(e[v], l);
+      return z !== Re && (n[v] = z), n;
+    }, new Array(t.length));
+    return t.length >= e.length ? a : a.concat(new Array(e.length - t.length).fill(void 0));
+  }
+  return me(e) && me(t) ? Object.keys({ ...e, ...t }).reduce((a, n) => {
+    let l = Te(e?.[n], t?.[n]);
+    return l === Re ? a : Object.assign(a, { [n]: l });
+  }, {}) : t;
+}, "deepDiff"), nr = /^[a-zA-Z0-9 _-]*$/, pn = /^-?[0-9]+(\.[0-9]+)?$/, ir = /^#([a-f0-9]{3,4}|[a-f0-9]{6}|[a-f0-9]{8})$/i, sr = /^(rgba?|hsla?)\(([0-9]{1,3}),\s?([0-9]{1,3})%?,\s?([0-9]{1,3})%?,?\s?([0-9](\.[0-9]{1,2})?)?\)$/i,
+Ze = /* @__PURE__ */ r((e = "", t) => e === null || e === "" || !nr.test(e) ? !1 : t == null || t instanceof Date || typeof t == "number" ||
+typeof t == "boolean" ? !0 : typeof t == "string" ? nr.test(t) || pn.test(t) || ir.test(t) || sr.test(t) : Array.isArray(t) ? t.every((a) => Ze(
+e, a)) : me(t) ? Object.entries(t).every(([a, n]) => Ze(a, n)) : !1, "validateArgs"), et = /* @__PURE__ */ r((e) => e === void 0 ? "!undefin\
+ed" : e === null ? "!null" : typeof e == "string" ? ir.test(e) ? `!hex(${e.slice(1)})` : sr.test(e) ? `!${e.replace(/[\s%]/g, "")}` : e : typeof e ==
+"boolean" ? `!${e}` : e instanceof Date ? `!date(${e.toISOString()})` : Array.isArray(e) ? e.map(et) : me(e) ? Object.entries(e).reduce(
+  (t, [a, n]) => Object.assign(t, { [a]: et(n) }),
+  {}
+) : e, "encodeSpecialValues"), dn = /* @__PURE__ */ r((e) => {
+  switch (e) {
+    case "%20":
+      return "+";
+    case "%5B":
+      return "[";
+    case "%5D":
+      return "]";
+    case "%2C":
+      return ",";
+    case "%3A":
+      return ":";
+  }
+  return e;
+}, "decodeKnownQueryChar"), mn = /%[0-9A-F]{2}/g, gn = /* @__PURE__ */ r((e, t) => {
+  let a = Te(e, t);
+  if (!a || a === Re)
+    return "";
+  let n = Object.entries(a).reduce((l, [v, z]) => Ze(v, z) ? Object.assign(l, { [v]: z }) : (ar.once.warn(or.dedent`
+      Omitted potentially unsafe URL args.
+
+      More info: https://storybook.js.org/docs/writing-stories/args#setting-args-through-the-url
+    `), l), {});
+  return (0, Ae.stringify)(et(n), {
+    delimiter: ";",
+    // we don't actually create multiple query params
+    nesting: !0,
+    nestingSyntax: "js"
+    // encode objects using dot notation: obj.key=val
+  }).replace(mn, dn).split(";").map((l) => l.replace("=", ":")).join(";");
+}, "buildArgsParam"), yn = (0, ke.default)(1e3)((e) => e !== void 0 ? (0, Ae.parse)(e) : {}), rt = /* @__PURE__ */ r((e) => yn(e.search ? e.
+search.slice(1) : ""), "queryFromLocation"), vn = /* @__PURE__ */ r((e) => {
+  let t = (0, Ae.stringify)(e);
+  return t ? "?" + t : "";
+}, "stringifyQuery"), nt = (0, ke.default)(1e3)((e, t, a = !0) => {
+  if (a) {
+    if (typeof t != "string")
+      throw new Error("startsWith only works with string targets");
+    return e && e.startsWith(t) ? { path: e } : null;
+  }
+  let n = typeof t == "string" && e === t, l = e && t && e.match(t);
+  return n || l ? { path: e } : null;
+});
+
+// src/router/router.tsx
+var xe = we(require("react"), 1), jr = require("@storybook/global"), de = we(Or(), 1);
+var { document: it } = jr.global, bn = /* @__PURE__ */ r(() => `${it.location.pathname}?`, "getBase"), xn = /* @__PURE__ */ r(() => {
+  let e = de.useNavigate();
+  return (0, xe.useCallback)((t, { plain: a, ...n } = {}) => {
+    if (typeof t == "string" && t.startsWith("#")) {
+      t === "#" ? e(it.location.search) : it.location.hash = t;
+      return;
+    }
+    if (typeof t == "string") {
+      let l = a ? t : `?path=${t}`;
+      return e(l, n);
+    }
+    if (typeof t == "number")
+      return e(t);
+  }, []);
+}, "useNavigate"), wr = /* @__PURE__ */ r(({ to: e, children: t, ...a }) => /* @__PURE__ */ xe.default.createElement(de.Link, { to: `${bn()}\
+path=${e}`, ...a }, t), "Link");
+wr.displayName = "QueryLink";
+var st = /* @__PURE__ */ r(({ children: e }) => {
+  let t = de.useLocation(), { path: a, singleStory: n } = rt(t), { viewMode: l, storyId: v, refId: z } = tt(a);
+  return /* @__PURE__ */ xe.default.createElement(xe.default.Fragment, null, e({
+    path: a || "/",
+    location: t,
+    viewMode: l,
+    storyId: v,
+    refId: z,
+    singleStory: n === "true"
+  }));
+}, "Location");
+st.displayName = "QueryLocation";
+function ut({
+  children: e,
+  path: t,
+  startsWith: a = !1
+}) {
+  return /* @__PURE__ */ xe.default.createElement(st, null, ({ path: n, ...l }) => e({
+    match: nt(n, t, a),
+    ...l
+  }));
+}
+r(ut, "Match");
+ut.displayName = "QueryMatch";
+function Sr(e) {
+  let { children: t, ...a } = e;
+  return a.startsWith === void 0 && (a.startsWith = !1), /* @__PURE__ */ xe.default.createElement(ut, { ...a }, ({ match: l }) => l ? t : null);
+}
+r(Sr, "Route");
+Sr.displayName = "Route";
+var Pn = /* @__PURE__ */ r((...e) => de.BrowserRouter(...e), "LocationProvider"), On = /* @__PURE__ */ r((...e) => de.Router(...e), "BaseLoc\
+ationProvider");