sequenceserver 2.0.0 → 2.1.0

data/public/vendor/npm/react-dom@18.0.0/cjs/react-dom-server.node.production.min.js

@@ -0,0 +1,1746 @@
+/* */ 
+(function(Buffer) {
+  'use strict';
+  var aa = require('react');
+  function ba(a) {
+    "function" === typeof a.cork && a.cork();
+  }
+  function ca(a) {
+    "function" === typeof a.uncork && a.uncork();
+  }
+  function k(a) {
+    return Buffer.from(a, "utf8");
+  }
+  var p = Object.prototype.hasOwnProperty,
+      da = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,
+      ea = {},
+      fa = {};
+  function ha(a) {
+    if (p.call(fa, a))
+      return !0;
+    if (p.call(ea, a))
+      return !1;
+    if (da.test(a))
+      return fa[a] = !0;
+    ea[a] = !0;
+    return !1;
+  }
+  function q(a, b, c, d, f, e, g) {
+    this.acceptsBooleans = 2 === b || 3 === b || 4 === b;
+    this.attributeName = d;
+    this.attributeNamespace = f;
+    this.mustUseProperty = c;
+    this.propertyName = a;
+    this.type = b;
+    this.sanitizeURL = e;
+    this.removeEmptyString = g;
+  }
+  var r = {};
+  "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a) {
+    r[a] = new q(a, 0, !1, a, null, !1, !1);
+  });
+  [["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(a) {
+    var b = a[0];
+    r[b] = new q(b, 1, !1, a[1], null, !1, !1);
+  });
+  ["contentEditable", "draggable", "spellCheck", "value"].forEach(function(a) {
+    r[a] = new q(a, 2, !1, a.toLowerCase(), null, !1, !1);
+  });
+  ["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(a) {
+    r[a] = new q(a, 2, !1, a, null, !1, !1);
+  });
+  "allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a) {
+    r[a] = new q(a, 3, !1, a.toLowerCase(), null, !1, !1);
+  });
+  ["checked", "multiple", "muted", "selected"].forEach(function(a) {
+    r[a] = new q(a, 3, !0, a, null, !1, !1);
+  });
+  ["capture", "download"].forEach(function(a) {
+    r[a] = new q(a, 4, !1, a, null, !1, !1);
+  });
+  ["cols", "rows", "size", "span"].forEach(function(a) {
+    r[a] = new q(a, 6, !1, a, null, !1, !1);
+  });
+  ["rowSpan", "start"].forEach(function(a) {
+    r[a] = new q(a, 5, !1, a.toLowerCase(), null, !1, !1);
+  });
+  var ia = /[\-:]([a-z])/g;
+  function ja(a) {
+    return a[1].toUpperCase();
+  }
+  "accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a) {
+    var b = a.replace(ia, ja);
+    r[b] = new q(b, 1, !1, a, null, !1, !1);
+  });
+  "xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a) {
+    var b = a.replace(ia, ja);
+    r[b] = new q(b, 1, !1, a, "http://www.w3.org/1999/xlink", !1, !1);
+  });
+  ["xml:base", "xml:lang", "xml:space"].forEach(function(a) {
+    var b = a.replace(ia, ja);
+    r[b] = new q(b, 1, !1, a, "http://www.w3.org/XML/1998/namespace", !1, !1);
+  });
+  ["tabIndex", "crossOrigin"].forEach(function(a) {
+    r[a] = new q(a, 1, !1, a.toLowerCase(), null, !1, !1);
+  });
+  r.xlinkHref = new q("xlinkHref", 1, !1, "xlink:href", "http://www.w3.org/1999/xlink", !0, !1);
+  ["src", "href", "action", "formAction"].forEach(function(a) {
+    r[a] = new q(a, 1, !1, a.toLowerCase(), null, !0, !0);
+  });
+  var t = {
+    animationIterationCount: !0,
+    aspectRatio: !0,
+    borderImageOutset: !0,
+    borderImageSlice: !0,
+    borderImageWidth: !0,
+    boxFlex: !0,
+    boxFlexGroup: !0,
+    boxOrdinalGroup: !0,
+    columnCount: !0,
+    columns: !0,
+    flex: !0,
+    flexGrow: !0,
+    flexPositive: !0,
+    flexShrink: !0,
+    flexNegative: !0,
+    flexOrder: !0,
+    gridArea: !0,
+    gridRow: !0,
+    gridRowEnd: !0,
+    gridRowSpan: !0,
+    gridRowStart: !0,
+    gridColumn: !0,
+    gridColumnEnd: !0,
+    gridColumnSpan: !0,
+    gridColumnStart: !0,
+    fontWeight: !0,
+    lineClamp: !0,
+    lineHeight: !0,
+    opacity: !0,
+    order: !0,
+    orphans: !0,
+    tabSize: !0,
+    widows: !0,
+    zIndex: !0,
+    zoom: !0,
+    fillOpacity: !0,
+    floodOpacity: !0,
+    stopOpacity: !0,
+    strokeDasharray: !0,
+    strokeDashoffset: !0,
+    strokeMiterlimit: !0,
+    strokeOpacity: !0,
+    strokeWidth: !0
+  },
+      ka = ["Webkit", "ms", "Moz", "O"];
+  Object.keys(t).forEach(function(a) {
+    ka.forEach(function(b) {
+      b = b + a.charAt(0).toUpperCase() + a.substring(1);
+      t[b] = t[a];
+    });
+  });
+  var la = /["'&<>]/;
+  function u(a) {
+    if ("boolean" === typeof a || "number" === typeof a)
+      return "" + a;
+    a = "" + a;
+    var b = la.exec(a);
+    if (b) {
+      var c = "",
+          d,
+          f = 0;
+      for (d = b.index; d < a.length; d++) {
+        switch (a.charCodeAt(d)) {
+          case 34:
+            b = "&quot;";
+            break;
+          case 38:
+            b = "&amp;";
+            break;
+          case 39:
+            b = "&#x27;";
+            break;
+          case 60:
+            b = "&lt;";
+            break;
+          case 62:
+            b = "&gt;";
+            break;
+          default:
+            continue;
+        }
+        f !== d && (c += a.substring(f, d));
+        f = d + 1;
+        c += b;
+      }
+      a = f !== d ? c + a.substring(f, d) : c;
+    }
+    return a;
+  }
+  var ma = /([A-Z])/g,
+      na = /^ms-/,
+      oa = Array.isArray,
+      pa = k("<script>"),
+      qa = k("\x3c/script>"),
+      ra = k('<script src="'),
+      sa = k('<script type="module" src="'),
+      ta = k('" async="">\x3c/script>');
+  function v(a, b) {
+    return {
+      insertionMode: a,
+      selectedValue: b
+    };
+  }
+  function ua(a, b, c) {
+    switch (b) {
+      case "select":
+        return v(1, null != c.value ? c.value : c.defaultValue);
+      case "svg":
+        return v(2, null);
+      case "math":
+        return v(3, null);
+      case "foreignObject":
+        return v(1, null);
+      case "table":
+        return v(4, null);
+      case "thead":
+      case "tbody":
+      case "tfoot":
+        return v(5, null);
+      case "colgroup":
+        return v(7, null);
+      case "tr":
+        return v(6, null);
+    }
+    return 4 <= a.insertionMode || 0 === a.insertionMode ? v(1, null) : a;
+  }
+  var va = k("\x3c!-- --\x3e"),
+      wa = new Map,
+      xa = k(' style="'),
+      ya = k(":"),
+      za = k(";");
+  function Aa(a, b, c) {
+    if ("object" !== typeof c)
+      throw Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");
+    b = !0;
+    for (var d in c)
+      if (p.call(c, d)) {
+        var f = c[d];
+        if (null != f && "boolean" !== typeof f && "" !== f) {
+          if (0 === d.indexOf("--")) {
+            var e = u(d);
+            f = u(("" + f).trim());
+          } else {
+            e = d;
+            var g = wa.get(e);
+            void 0 !== g ? e = g : (g = k(u(e.replace(ma, "-$1").toLowerCase().replace(na, "-ms-"))), wa.set(e, g), e = g);
+            f = "number" === typeof f ? 0 === f || p.call(t, d) ? "" + f : f + "px" : u(("" + f).trim());
+          }
+          b ? (b = !1, a.push(xa, e, ya, f)) : a.push(za, e, ya, f);
+        }
+      }
+    b || a.push(x);
+  }
+  var z = k(" "),
+      A = k('="'),
+      x = k('"'),
+      Ba = k('=""');
+  function C(a, b, c, d) {
+    switch (c) {
+      case "style":
+        Aa(a, b, d);
+        return;
+      case "defaultValue":
+      case "defaultChecked":
+      case "innerHTML":
+      case "suppressContentEditableWarning":
+      case "suppressHydrationWarning":
+        return;
+    }
+    if (!(2 < c.length) || "o" !== c[0] && "O" !== c[0] || "n" !== c[1] && "N" !== c[1])
+      if (b = r.hasOwnProperty(c) ? r[c] : null, null !== b) {
+        switch (typeof d) {
+          case "function":
+          case "symbol":
+            return;
+          case "boolean":
+            if (!b.acceptsBooleans)
+              return;
+        }
+        c = b.attributeName;
+        switch (b.type) {
+          case 3:
+            d && a.push(z, c, Ba);
+            break;
+          case 4:
+            !0 === d ? a.push(z, c, Ba) : !1 !== d && a.push(z, c, A, u(d), x);
+            break;
+          case 5:
+            isNaN(d) || a.push(z, c, A, u(d), x);
+            break;
+          case 6:
+            !isNaN(d) && 1 <= d && a.push(z, c, A, u(d), x);
+            break;
+          default:
+            b.sanitizeURL && (d = "" + d), a.push(z, c, A, u(d), x);
+        }
+      } else if (ha(c)) {
+        switch (typeof d) {
+          case "function":
+          case "symbol":
+            return;
+          case "boolean":
+            if (b = c.toLowerCase().slice(0, 5), "data-" !== b && "aria-" !== b)
+              return;
+        }
+        a.push(z, c, A, u(d), x);
+      }
+  }
+  var D = k(">"),
+      Ca = k("/>");
+  function E(a, b, c) {
+    if (null != b) {
+      if (null != c)
+        throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
+      if ("object" !== typeof b || !("__html" in b))
+        throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");
+      b = b.__html;
+      null !== b && void 0 !== b && a.push("" + b);
+    }
+  }
+  function Da(a) {
+    var b = "";
+    aa.Children.forEach(a, function(a) {
+      null != a && (b += a);
+    });
+    return b;
+  }
+  var Ea = k(' selected=""');
+  function Fa(a, b, c, d) {
+    a.push(F(c));
+    var f = c = null,
+        e;
+    for (e in b)
+      if (p.call(b, e)) {
+        var g = b[e];
+        if (null != g)
+          switch (e) {
+            case "children":
+              c = g;
+              break;
+            case "dangerouslySetInnerHTML":
+              f = g;
+              break;
+            default:
+              C(a, d, e, g);
+          }
+      }
+    a.push(D);
+    E(a, f, c);
+    return "string" === typeof c ? (a.push(u(c)), null) : c;
+  }
+  var Ga = k("\n"),
+      Ha = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,
+      Ia = new Map;
+  function F(a) {
+    var b = Ia.get(a);
+    if (void 0 === b) {
+      if (!Ha.test(a))
+        throw Error("Invalid tag: " + a);
+      b = k("<" + a);
+      Ia.set(a, b);
+    }
+    return b;
+  }
+  var Ja = k("<!DOCTYPE html>");
+  function Ka(a, b, c, d, f) {
+    switch (b) {
+      case "select":
+        a.push(F("select"));
+        var e = null,
+            g = null;
+        for (n in c)
+          if (p.call(c, n)) {
+            var h = c[n];
+            if (null != h)
+              switch (n) {
+                case "children":
+                  e = h;
+                  break;
+                case "dangerouslySetInnerHTML":
+                  g = h;
+                  break;
+                case "defaultValue":
+                case "value":
+                  break;
+                default:
+                  C(a, d, n, h);
+              }
+          }
+        a.push(D);
+        E(a, g, e);
+        return e;
+      case "option":
+        g = f.selectedValue;
+        a.push(F("option"));
+        var l = h = null,
+            m = null;
+        var n = null;
+        for (e in c)
+          if (p.call(c, e) && (b = c[e], null != b))
+            switch (e) {
+              case "children":
+                h = b;
+                break;
+              case "selected":
+                m = b;
+                break;
+              case "dangerouslySetInnerHTML":
+                n = b;
+                break;
+              case "value":
+                l = b;
+              default:
+                C(a, d, e, b);
+            }
+        if (null != g)
+          if (c = null !== l ? "" + l : Da(h), oa(g))
+            for (d = 0; d < g.length; d++) {
+              if ("" + g[d] === c) {
+                a.push(Ea);
+                break;
+              }
+            }
+          else
+            "" + g === c && a.push(Ea);
+        else
+          m && a.push(Ea);
+        a.push(D);
+        E(a, n, h);
+        return h;
+      case "textarea":
+        a.push(F("textarea"));
+        n = g = e = null;
+        for (h in c)
+          if (p.call(c, h) && (l = c[h], null != l))
+            switch (h) {
+              case "children":
+                n = l;
+                break;
+              case "value":
+                e = l;
+                break;
+              case "defaultValue":
+                g = l;
+                break;
+              case "dangerouslySetInnerHTML":
+                throw Error("`dangerouslySetInnerHTML` does not make sense on <textarea>.");
+              default:
+                C(a, d, h, l);
+            }
+        null === e && null !== g && (e = g);
+        a.push(D);
+        if (null != n) {
+          if (null != e)
+            throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");
+          if (oa(n) && 1 < n.length)
+            throw Error("<textarea> can only have at most one child.");
+          e = "" + n;
+        }
+        "string" === typeof e && "\n" === e[0] && a.push(Ga);
+        null !== e && a.push(u("" + e));
+        return null;
+      case "input":
+        a.push(F("input"));
+        l = n = h = e = null;
+        for (g in c)
+          if (p.call(c, g) && (m = c[g], null != m))
+            switch (g) {
+              case "children":
+              case "dangerouslySetInnerHTML":
+                throw Error("input is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
+              case "defaultChecked":
+                l = m;
+                break;
+              case "defaultValue":
+                h = m;
+                break;
+              case "checked":
+                n = m;
+                break;
+              case "value":
+                e = m;
+                break;
+              default:
+                C(a, d, g, m);
+            }
+        null !== n ? C(a, d, "checked", n) : null !== l && C(a, d, "checked", l);
+        null !== e ? C(a, d, "value", e) : null !== h && C(a, d, "value", h);
+        a.push(Ca);
+        return null;
+      case "menuitem":
+        a.push(F("menuitem"));
+        for (var y in c)
+          if (p.call(c, y) && (e = c[y], null != e))
+            switch (y) {
+              case "children":
+              case "dangerouslySetInnerHTML":
+                throw Error("menuitems cannot have `children` nor `dangerouslySetInnerHTML`.");
+              default:
+                C(a, d, y, e);
+            }
+        a.push(D);
+        return null;
+      case "listing":
+      case "pre":
+        a.push(F(b));
+        g = e = null;
+        for (l in c)
+          if (p.call(c, l) && (h = c[l], null != h))
+            switch (l) {
+              case "children":
+                e = h;
+                break;
+              case "dangerouslySetInnerHTML":
+                g = h;
+                break;
+              default:
+                C(a, d, l, h);
+            }
+        a.push(D);
+        if (null != g) {
+          if (null != e)
+            throw Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
+          if ("object" !== typeof g || !("__html" in g))
+            throw Error("`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://reactjs.org/link/dangerously-set-inner-html for more information.");
+          c = g.__html;
+          null !== c && void 0 !== c && ("string" === typeof c && 0 < c.length && "\n" === c[0] ? a.push(Ga, c) : a.push("" + c));
+        }
+        "string" === typeof e && "\n" === e[0] && a.push(Ga);
+        return e;
+      case "area":
+      case "base":
+      case "br":
+      case "col":
+      case "embed":
+      case "hr":
+      case "img":
+      case "keygen":
+      case "link":
+      case "meta":
+      case "param":
+      case "source":
+      case "track":
+      case "wbr":
+        a.push(F(b));
+        for (var B in c)
+          if (p.call(c, B) && (e = c[B], null != e))
+            switch (B) {
+              case "children":
+              case "dangerouslySetInnerHTML":
+                throw Error(b + " is a self-closing tag and must neither have `children` nor use `dangerouslySetInnerHTML`.");
+              default:
+                C(a, d, B, e);
+            }
+        a.push(Ca);
+        return null;
+      case "annotation-xml":
+      case "color-profile":
+      case "font-face":
+      case "font-face-src":
+      case "font-face-uri":
+      case "font-face-format":
+      case "font-face-name":
+      case "missing-glyph":
+        return Fa(a, c, b, d);
+      case "html":
+        return 0 === f.insertionMode && a.push(Ja), Fa(a, c, b, d);
+      default:
+        if (-1 === b.indexOf("-") && "string" !== typeof c.is)
+          return Fa(a, c, b, d);
+        a.push(F(b));
+        g = e = null;
+        for (m in c)
+          if (p.call(c, m) && (h = c[m], null != h))
+            switch (m) {
+              case "children":
+                e = h;
+                break;
+              case "dangerouslySetInnerHTML":
+                g = h;
+                break;
+              case "style":
+                Aa(a, d, h);
+                break;
+              case "suppressContentEditableWarning":
+              case "suppressHydrationWarning":
+                break;
+              default:
+                ha(m) && "function" !== typeof h && "symbol" !== typeof h && a.push(z, m, A, u(h), x);
+            }
+        a.push(D);
+        E(a, g, e);
+        return e;
+    }
+  }
+  var La = k("</"),
+      Ma = k(">"),
+      Na = k('<template id="'),
+      Oa = k('"></template>'),
+      Pa = k("\x3c!--$--\x3e"),
+      Qa = k('\x3c!--$?--\x3e<template id="'),
+      Ra = k('"></template>'),
+      Sa = k("\x3c!--$!--\x3e"),
+      Ta = k("\x3c!--/$--\x3e");
+  function Ua(a, b, c) {
+    a.write(Qa);
+    if (null === c)
+      throw Error("An ID must have been assigned before we can complete the boundary.");
+    a.write(c);
+    return a.write(Ra);
+  }
+  var Va = k('<div hidden id="'),
+      Wa = k('">'),
+      Xa = k("</div>"),
+      Ya = k('<svg aria-hidden="true" style="display:none" id="'),
+      Za = k('">'),
+      $a = k("</svg>"),
+      ab = k('<math aria-hidden="true" style="display:none" id="'),
+      bb = k('">'),
+      cb = k("</math>"),
+      db = k('<table hidden id="'),
+      eb = k('">'),
+      fb = k("</table>"),
+      gb = k('<table hidden><tbody id="'),
+      hb = k('">'),
+      ib = k("</tbody></table>"),
+      jb = k('<table hidden><tr id="'),
+      kb = k('">'),
+      lb = k("</tr></table>"),
+      mb = k('<table hidden><colgroup id="'),
+      nb = k('">'),
+      ob = k("</colgroup></table>");
+  function pb(a, b, c, d) {
+    switch (c.insertionMode) {
+      case 0:
+      case 1:
+        return a.write(Va), a.write(b.segmentPrefix), b = d.toString(16), a.write(b), a.write(Wa);
+      case 2:
+        return a.write(Ya), a.write(b.segmentPrefix), b = d.toString(16), a.write(b), a.write(Za);
+      case 3:
+        return a.write(ab), a.write(b.segmentPrefix), b = d.toString(16), a.write(b), a.write(bb);
+      case 4:
+        return a.write(db), a.write(b.segmentPrefix), b = d.toString(16), a.write(b), a.write(eb);
+      case 5:
+        return a.write(gb), a.write(b.segmentPrefix), b = d.toString(16), a.write(b), a.write(hb);
+      case 6:
+        return a.write(jb), a.write(b.segmentPrefix), b = d.toString(16), a.write(b), a.write(kb);
+      case 7:
+        return a.write(mb), a.write(b.segmentPrefix), b = d.toString(16), a.write(b), a.write(nb);
+      default:
+        throw Error("Unknown insertion mode. This is a bug in React.");
+    }
+  }
+  function qb(a, b) {
+    switch (b.insertionMode) {
+      case 0:
+      case 1:
+        return a.write(Xa);
+      case 2:
+        return a.write($a);
+      case 3:
+        return a.write(cb);
+      case 4:
+        return a.write(fb);
+      case 5:
+        return a.write(ib);
+      case 6:
+        return a.write(lb);
+      case 7:
+        return a.write(ob);
+      default:
+        throw Error("Unknown insertion mode. This is a bug in React.");
+    }
+  }
+  var rb = k('function $RS(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("'),
+      sb = k('$RS("'),
+      tb = k('","'),
+      ub = k('")\x3c/script>'),
+      vb = k('function $RC(a,b){a=document.getElementById(a);b=document.getElementById(b);b.parentNode.removeChild(b);if(a){a=a.previousSibling;var f=a.parentNode,c=a.nextSibling,e=0;do{if(c&&8===c.nodeType){var d=c.data;if("/$"===d)if(0===e)break;else e--;else"$"!==d&&"$?"!==d&&"$!"!==d||e++}d=c.nextSibling;f.removeChild(c);c=d}while(c);for(;b.firstChild;)f.insertBefore(b.firstChild,c);a.data="$";a._reactRetry&&a._reactRetry()}};$RC("'),
+      wb = k('$RC("'),
+      xb = k('","'),
+      yb = k('")\x3c/script>'),
+      zb = k('function $RX(a){if(a=document.getElementById(a))a=a.previousSibling,a.data="$!",a._reactRetry&&a._reactRetry()};$RX("'),
+      Ab = k('$RX("'),
+      Bb = k('")\x3c/script>'),
+      G = Object.assign,
+      Cb = Symbol.for("react.element"),
+      Db = Symbol.for("react.portal"),
+      Eb = Symbol.for("react.fragment"),
+      Fb = Symbol.for("react.strict_mode"),
+      Gb = Symbol.for("react.profiler"),
+      Hb = Symbol.for("react.provider"),
+      Ib = Symbol.for("react.context"),
+      Jb = Symbol.for("react.forward_ref"),
+      Kb = Symbol.for("react.suspense"),
+      Lb = Symbol.for("react.suspense_list"),
+      Mb = Symbol.for("react.memo"),
+      Nb = Symbol.for("react.lazy"),
+      Ob = Symbol.for("react.scope"),
+      Pb = Symbol.for("react.debug_trace_mode"),
+      Qb = Symbol.for("react.legacy_hidden"),
+      Rb = Symbol.for("react.default_value"),
+      Sb = Symbol.iterator;
+  function Tb(a) {
+    if (null == a)
+      return null;
+    if ("function" === typeof a)
+      return a.displayName || a.name || null;
+    if ("string" === typeof a)
+      return a;
+    switch (a) {
+      case Eb:
+        return "Fragment";
+      case Db:
+        return "Portal";
+      case Gb:
+        return "Profiler";
+      case Fb:
+        return "StrictMode";
+      case Kb:
+        return "Suspense";
+      case Lb:
+        return "SuspenseList";
+    }
+    if ("object" === typeof a)
+      switch (a.$$typeof) {
+        case Ib:
+          return (a.displayName || "Context") + ".Consumer";
+        case Hb:
+          return (a._context.displayName || "Context") + ".Provider";
+        case Jb:
+          var b = a.render;
+          a = a.displayName;
+          a || (a = b.displayName || b.name || "", a = "" !== a ? "ForwardRef(" + a + ")" : "ForwardRef");
+          return a;
+        case Mb:
+          return b = a.displayName || null, null !== b ? b : Tb(a.type) || "Memo";
+        case Nb:
+          b = a._payload;
+          a = a._init;
+          try {
+            return Tb(a(b));
+          } catch (c) {}
+      }
+    return null;
+  }
+  var Ub = {};
+  function Vb(a, b) {
+    a = a.contextTypes;
+    if (!a)
+      return Ub;
+    var c = {},
+        d;
+    for (d in a)
+      c[d] = b[d];
+    return c;
+  }
+  var H = null;
+  function I(a, b) {
+    if (a !== b) {
+      a.context._currentValue = a.parentValue;
+      a = a.parent;
+      var c = b.parent;
+      if (null === a) {
+        if (null !== c)
+          throw Error("The stacks must reach the root at the same time. This is a bug in React.");
+      } else {
+        if (null === c)
+          throw Error("The stacks must reach the root at the same time. This is a bug in React.");
+        I(a, c);
+      }
+      b.context._currentValue = b.value;
+    }
+  }
+  function Wb(a) {
+    a.context._currentValue = a.parentValue;
+    a = a.parent;
+    null !== a && Wb(a);
+  }
+  function Xb(a) {
+    var b = a.parent;
+    null !== b && Xb(b);
+    a.context._currentValue = a.value;
+  }
+  function Yb(a, b) {
+    a.context._currentValue = a.parentValue;
+    a = a.parent;
+    if (null === a)
+      throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");
+    a.depth === b.depth ? I(a, b) : Yb(a, b);
+  }
+  function Zb(a, b) {
+    var c = b.parent;
+    if (null === c)
+      throw Error("The depth must equal at least at zero before reaching the root. This is a bug in React.");
+    a.depth === c.depth ? I(a, c) : Zb(a, c);
+    b.context._currentValue = b.value;
+  }
+  function J(a) {
+    var b = H;
+    b !== a && (null === b ? Xb(a) : null === a ? Wb(b) : b.depth === a.depth ? I(b, a) : b.depth > a.depth ? Yb(b, a) : Zb(b, a), H = a);
+  }
+  var $b = {
+    isMounted: function() {
+      return !1;
+    },
+    enqueueSetState: function(a, b) {
+      a = a._reactInternals;
+      null !== a.queue && a.queue.push(b);
+    },
+    enqueueReplaceState: function(a, b) {
+      a = a._reactInternals;
+      a.replace = !0;
+      a.queue = [b];
+    },
+    enqueueForceUpdate: function() {}
+  };
+  function ac(a, b, c, d) {
+    var f = void 0 !== a.state ? a.state : null;
+    a.updater = $b;
+    a.props = c;
+    a.state = f;
+    var e = {
+      queue: [],
+      replace: !1
+    };
+    a._reactInternals = e;
+    var g = b.contextType;
+    a.context = "object" === typeof g && null !== g ? g._currentValue : d;
+    g = b.getDerivedStateFromProps;
+    "function" === typeof g && (g = g(c, f), f = null === g || void 0 === g ? f : G({}, f, g), a.state = f);
+    if ("function" !== typeof b.getDerivedStateFromProps && "function" !== typeof a.getSnapshotBeforeUpdate && ("function" === typeof a.UNSAFE_componentWillMount || "function" === typeof a.componentWillMount))
+      if (b = a.state, "function" === typeof a.componentWillMount && a.componentWillMount(), "function" === typeof a.UNSAFE_componentWillMount && a.UNSAFE_componentWillMount(), b !== a.state && $b.enqueueReplaceState(a, a.state, null), null !== e.queue && 0 < e.queue.length)
+        if (b = e.queue, g = e.replace, e.queue = null, e.replace = !1, g && 1 === b.length)
+          a.state = b[0];
+        else {
+          e = g ? b[0] : a.state;
+          f = !0;
+          for (g = g ? 1 : 0; g < b.length; g++) {
+            var h = b[g];
+            h = "function" === typeof h ? h.call(a, e, c, d) : h;
+            null != h && (f ? (f = !1, e = G({}, e, h)) : G(e, h));
+          }
+          a.state = e;
+        }
+      else
+        e.queue = null;
+  }
+  var bc = {
+    id: 1,
+    overflow: ""
+  };
+  function cc(a, b, c) {
+    var d = a.id;
+    a = a.overflow;
+    var f = 32 - K(d) - 1;
+    d &= ~(1 << f);
+    c += 1;
+    var e = 32 - K(b) + f;
+    if (30 < e) {
+      var g = f - f % 5;
+      e = (d & (1 << g) - 1).toString(32);
+      d >>= g;
+      f -= g;
+      return {
+        id: 1 << 32 - K(b) + f | c << f | d,
+        overflow: e + a
+      };
+    }
+    return {
+      id: 1 << e | c << f | d,
+      overflow: a
+    };
+  }
+  var K = Math.clz32 ? Math.clz32 : dc,
+      ec = Math.log,
+      fc = Math.LN2;
+  function dc(a) {
+    a >>>= 0;
+    return 0 === a ? 32 : 31 - (ec(a) / fc | 0) | 0;
+  }
+  function gc(a, b) {
+    return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
+  }
+  var hc = "function" === typeof Object.is ? Object.is : gc,
+      L = null,
+      ic = null,
+      M = null,
+      N = null,
+      O = !1,
+      P = !1,
+      Q = 0,
+      R = null,
+      S = 0;
+  function T() {
+    if (null === L)
+      throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");
+    return L;
+  }
+  function jc() {
+    if (0 < S)
+      throw Error("Rendered more hooks than during the previous render");
+    return {
+      memoizedState: null,
+      queue: null,
+      next: null
+    };
+  }
+  function kc() {
+    null === N ? null === M ? (O = !1, M = N = jc()) : (O = !0, N = M) : null === N.next ? (O = !1, N = N.next = jc()) : (O = !0, N = N.next);
+    return N;
+  }
+  function lc() {
+    ic = L = null;
+    P = !1;
+    M = null;
+    S = 0;
+    N = R = null;
+  }
+  function mc(a, b) {
+    return "function" === typeof b ? b(a) : b;
+  }
+  function nc(a, b, c) {
+    L = T();
+    N = kc();
+    if (O) {
+      var d = N.queue;
+      b = d.dispatch;
+      if (null !== R && (c = R.get(d), void 0 !== c)) {
+        R.delete(d);
+        d = N.memoizedState;
+        do
+          d = a(d, c.action), c = c.next;
+ while (null !== c);
+        N.memoizedState = d;
+        return [d, b];
+      }
+      return [N.memoizedState, b];
+    }
+    a = a === mc ? "function" === typeof b ? b() : b : void 0 !== c ? c(b) : b;
+    N.memoizedState = a;
+    a = N.queue = {
+      last: null,
+      dispatch: null
+    };
+    a = a.dispatch = oc.bind(null, L, a);
+    return [N.memoizedState, a];
+  }
+  function pc(a, b) {
+    L = T();
+    N = kc();
+    b = void 0 === b ? null : b;
+    if (null !== N) {
+      var c = N.memoizedState;
+      if (null !== c && null !== b) {
+        var d = c[1];
+        a: if (null === d)
+          d = !1;
+        else {
+          for (var f = 0; f < d.length && f < b.length; f++)
+            if (!hc(b[f], d[f])) {
+              d = !1;
+              break a;
+            }
+          d = !0;
+        }
+        if (d)
+          return c[0];
+      }
+    }
+    a = a();
+    N.memoizedState = [a, b];
+    return a;
+  }
+  function oc(a, b, c) {
+    if (25 <= S)
+      throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");
+    if (a === L)
+      if (P = !0, a = {
+        action: c,
+        next: null
+      }, null === R && (R = new Map), c = R.get(b), void 0 === c)
+        R.set(b, a);
+      else {
+        for (b = c; null !== b.next; )
+          b = b.next;
+        b.next = a;
+      }
+  }
+  function qc() {
+    throw Error("startTransition cannot be called during server rendering.");
+  }
+  function U() {}
+  var rc = {
+    readContext: function(a) {
+      return a._currentValue;
+    },
+    useContext: function(a) {
+      T();
+      return a._currentValue;
+    },
+    useMemo: pc,
+    useReducer: nc,
+    useRef: function(a) {
+      L = T();
+      N = kc();
+      var b = N.memoizedState;
+      return null === b ? (a = {current: a}, N.memoizedState = a) : b;
+    },
+    useState: function(a) {
+      return nc(mc, a);
+    },
+    useInsertionEffect: U,
+    useLayoutEffect: function() {},
+    useCallback: function(a, b) {
+      return pc(function() {
+        return a;
+      }, b);
+    },
+    useImperativeHandle: U,
+    useEffect: U,
+    useDebugValue: U,
+    useDeferredValue: function(a) {
+      T();
+      return a;
+    },
+    useTransition: function() {
+      T();
+      return [!1, qc];
+    },
+    useId: function() {
+      var a = ic.treeContext;
+      var b = a.overflow;
+      a = a.id;
+      a = (a & ~(1 << 32 - K(a) - 1)).toString(32) + b;
+      var c = V;
+      if (null === c)
+        throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component.");
+      b = Q++;
+      a = ":" + c.idPrefix + "R" + a;
+      0 < b && (a += "H" + b.toString(32));
+      return a + ":";
+    },
+    useMutableSource: function(a, b) {
+      T();
+      return b(a._source);
+    },
+    useSyncExternalStore: function(a, b, c) {
+      if (void 0 === c)
+        throw Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");
+      return c();
+    }
+  },
+      V = null,
+      sc = aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher;
+  function tc(a) {
+    console.error(a);
+  }
+  function W() {}
+  function uc(a, b) {
+    var c = a.pingedTasks;
+    c.push(b);
+    1 === c.length && setImmediate(function() {
+      return vc(a);
+    });
+  }
+  function wc(a, b, c, d, f, e, g, h) {
+    a.allPendingTasks++;
+    null === c ? a.pendingRootTasks++ : c.pendingTasks++;
+    var l = {
+      node: b,
+      ping: function() {
+        return uc(a, l);
+      },
+      blockedBoundary: c,
+      blockedSegment: d,
+      abortSet: f,
+      legacyContext: e,
+      context: g,
+      treeContext: h
+    };
+    f.add(l);
+    return l;
+  }
+  function X(a, b, c, d) {
+    return {
+      status: 0,
+      id: -1,
+      index: b,
+      parentFlushed: !1,
+      chunks: [],
+      children: [],
+      formatContext: d,
+      boundary: c
+    };
+  }
+  function Y(a, b) {
+    a = a.onError;
+    a(b);
+  }
+  function xc(a, b) {
+    var c = a.onShellError;
+    c(b);
+    c = a.onFatalError;
+    c(b);
+    null !== a.destination ? (a.status = 2, a.destination.destroy(b)) : (a.status = 1, a.fatalError = b);
+  }
+  function yc(a, b, c, d, f) {
+    L = {};
+    ic = b;
+    Q = 0;
+    for (a = c(d, f); P; )
+      P = !1, Q = 0, S += 1, N = null, a = c(d, f);
+    lc();
+    return a;
+  }
+  function zc(a, b, c, d) {
+    var f = c.render(),
+        e = d.childContextTypes;
+    if (null !== e && void 0 !== e) {
+      var g = b.legacyContext;
+      if ("function" !== typeof c.getChildContext)
+        d = g;
+      else {
+        c = c.getChildContext();
+        for (var h in c)
+          if (!(h in e))
+            throw Error((Tb(d) || "Unknown") + '.getChildContext(): key "' + h + '" is not defined in childContextTypes.');
+        d = G({}, g, c);
+      }
+      b.legacyContext = d;
+      Z(a, b, f);
+      b.legacyContext = g;
+    } else
+      Z(a, b, f);
+  }
+  function Ac(a, b) {
+    if (a && a.defaultProps) {
+      b = G({}, b);
+      a = a.defaultProps;
+      for (var c in a)
+        void 0 === b[c] && (b[c] = a[c]);
+      return b;
+    }
+    return b;
+  }
+  function Bc(a, b, c, d, f) {
+    if ("function" === typeof c)
+      if (c.prototype && c.prototype.isReactComponent) {
+        f = Vb(c, b.legacyContext);
+        var e = c.contextType;
+        e = new c(d, "object" === typeof e && null !== e ? e._currentValue : f);
+        ac(e, c, d, f);
+        zc(a, b, e, c);
+      } else {
+        e = Vb(c, b.legacyContext);
+        f = yc(a, b, c, d, e);
+        var g = 0 !== Q;
+        if ("object" === typeof f && null !== f && "function" === typeof f.render && void 0 === f.$$typeof)
+          ac(f, c, d, e), zc(a, b, f, c);
+        else if (g) {
+          d = b.treeContext;
+          b.treeContext = cc(d, 1, 0);
+          try {
+            Z(a, b, f);
+          } finally {
+            b.treeContext = d;
+          }
+        } else
+          Z(a, b, f);
+      }
+    else if ("string" === typeof c)
+      switch (f = b.blockedSegment, e = Ka(f.chunks, c, d, a.responseState, f.formatContext), g = f.formatContext, f.formatContext = ua(g, c, d), Cc(a, b, e), f.formatContext = g, c) {
+        case "area":
+        case "base":
+        case "br":
+        case "col":
+        case "embed":
+        case "hr":
+        case "img":
+        case "input":
+        case "keygen":
+        case "link":
+        case "meta":
+        case "param":
+        case "source":
+        case "track":
+        case "wbr":
+          break;
+        default:
+          f.chunks.push(La, c, Ma);
+      }
+    else {
+      switch (c) {
+        case Qb:
+        case Pb:
+        case Fb:
+        case Gb:
+        case Eb:
+          Z(a, b, d.children);
+          return;
+        case Lb:
+          Z(a, b, d.children);
+          return;
+        case Ob:
+          throw Error("ReactDOMServer does not yet support scope components.");
+        case Kb:
+          a: {
+            c = b.blockedBoundary;
+            f = b.blockedSegment;
+            e = d.fallback;
+            d = d.children;
+            g = new Set;
+            var h = {
+              id: null,
+              rootSegmentID: -1,
+              parentFlushed: !1,
+              pendingTasks: 0,
+              forceClientRender: !1,
+              completedSegments: [],
+              byteSize: 0,
+              fallbackAbortableTasks: g
+            },
+                l = X(a, f.chunks.length, h, f.formatContext);
+            f.children.push(l);
+            var m = X(a, 0, null, f.formatContext);
+            m.parentFlushed = !0;
+            b.blockedBoundary = h;
+            b.blockedSegment = m;
+            try {
+              if (Cc(a, b, d), m.status = 1, Dc(h, m), 0 === h.pendingTasks)
+                break a;
+            } catch (n) {
+              m.status = 4, Y(a, n), h.forceClientRender = !0;
+            } finally {
+              b.blockedBoundary = c, b.blockedSegment = f;
+            }
+            b = wc(a, e, c, l, g, b.legacyContext, b.context, b.treeContext);
+            a.pingedTasks.push(b);
+          }
+          return;
+      }
+      if ("object" === typeof c && null !== c)
+        switch (c.$$typeof) {
+          case Jb:
+            d = yc(a, b, c.render, d, f);
+            if (0 !== Q) {
+              c = b.treeContext;
+              b.treeContext = cc(c, 1, 0);
+              try {
+                Z(a, b, d);
+              } finally {
+                b.treeContext = c;
+              }
+            } else
+              Z(a, b, d);
+            return;
+          case Mb:
+            c = c.type;
+            d = Ac(c, d);
+            Bc(a, b, c, d, f);
+            return;
+          case Hb:
+            f = d.children;
+            c = c._context;
+            d = d.value;
+            e = c._currentValue;
+            c._currentValue = d;
+            g = H;
+            H = d = {
+              parent: g,
+              depth: null === g ? 0 : g.depth + 1,
+              context: c,
+              parentValue: e,
+              value: d
+            };
+            b.context = d;
+            Z(a, b, f);
+            a = H;
+            if (null === a)
+              throw Error("Tried to pop a Context at the root of the app. This is a bug in React.");
+            d = a.parentValue;
+            a.context._currentValue = d === Rb ? a.context._defaultValue : d;
+            a = H = a.parent;
+            b.context = a;
+            return;
+          case Ib:
+            d = d.children;
+            d = d(c._currentValue);
+            Z(a, b, d);
+            return;
+          case Nb:
+            f = c._init;
+            c = f(c._payload);
+            d = Ac(c, d);
+            Bc(a, b, c, d, void 0);
+            return;
+        }
+      throw Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + ((null == c ? c : typeof c) + "."));
+    }
+  }
+  function Z(a, b, c) {
+    b.node = c;
+    if ("object" === typeof c && null !== c) {
+      switch (c.$$typeof) {
+        case Cb:
+          Bc(a, b, c.type, c.props, c.ref);
+          return;
+        case Db:
+          throw Error("Portals are not currently supported by the server renderer. Render them conditionally so that they only appear on the client render.");
+        case Nb:
+          var d = c._init;
+          c = d(c._payload);
+          Z(a, b, c);
+          return;
+      }
+      if (oa(c)) {
+        Ec(a, b, c);
+        return;
+      }
+      null === c || "object" !== typeof c ? d = null : (d = Sb && c[Sb] || c["@@iterator"], d = "function" === typeof d ? d : null);
+      if (d && (d = d.call(c))) {
+        c = d.next();
+        if (!c.done) {
+          var f = [];
+          do
+            f.push(c.value), c = d.next();
+ while (!c.done);
+          Ec(a, b, f);
+        }
+        return;
+      }
+      b = Object.prototype.toString.call(c);
+      throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(c).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+    }
+    "string" === typeof c ? "" !== c && b.blockedSegment.chunks.push(u(c), va) : "number" === typeof c && (a = "" + c, "" !== a && b.blockedSegment.chunks.push(u(a), va));
+  }
+  function Ec(a, b, c) {
+    for (var d = c.length,
+        f = 0; f < d; f++) {
+      var e = b.treeContext;
+      b.treeContext = cc(e, d, f);
+      try {
+        Cc(a, b, c[f]);
+      } finally {
+        b.treeContext = e;
+      }
+    }
+  }
+  function Cc(a, b, c) {
+    var d = b.blockedSegment.formatContext,
+        f = b.legacyContext,
+        e = b.context;
+    try {
+      return Z(a, b, c);
+    } catch (l) {
+      if (lc(), "object" === typeof l && null !== l && "function" === typeof l.then) {
+        c = l;
+        var g = b.blockedSegment,
+            h = X(a, g.chunks.length, null, g.formatContext);
+        g.children.push(h);
+        a = wc(a, b.node, b.blockedBoundary, h, b.abortSet, b.legacyContext, b.context, b.treeContext).ping;
+        c.then(a, a);
+        b.blockedSegment.formatContext = d;
+        b.legacyContext = f;
+        b.context = e;
+        J(e);
+      } else
+        throw b.blockedSegment.formatContext = d, b.legacyContext = f, b.context = e, J(e), l;
+    }
+  }
+  function Fc(a) {
+    var b = a.blockedBoundary;
+    a = a.blockedSegment;
+    a.status = 3;
+    Gc(this, b, a);
+  }
+  function Hc(a) {
+    var b = a.blockedBoundary;
+    a.blockedSegment.status = 3;
+    null === b ? (this.allPendingTasks--, 2 !== this.status && (this.status = 2, null !== this.destination && this.destination.end())) : (b.pendingTasks--, b.forceClientRender || (b.forceClientRender = !0, b.parentFlushed && this.clientRenderedBoundaries.push(b)), b.fallbackAbortableTasks.forEach(Hc, this), b.fallbackAbortableTasks.clear(), this.allPendingTasks--, 0 === this.allPendingTasks && (a = this.onAllReady, a()));
+  }
+  function Dc(a, b) {
+    if (0 === b.chunks.length && 1 === b.children.length && null === b.children[0].boundary) {
+      var c = b.children[0];
+      c.id = b.id;
+      c.parentFlushed = !0;
+      1 === c.status && Dc(a, c);
+    } else
+      a.completedSegments.push(b);
+  }
+  function Gc(a, b, c) {
+    if (null === b) {
+      if (c.parentFlushed) {
+        if (null !== a.completedRootSegment)
+          throw Error("There can only be one root segment. This is a bug in React.");
+        a.completedRootSegment = c;
+      }
+      a.pendingRootTasks--;
+      0 === a.pendingRootTasks && (a.onShellError = W, b = a.onShellReady, b());
+    } else
+      b.pendingTasks--, b.forceClientRender || (0 === b.pendingTasks ? (c.parentFlushed && 1 === c.status && Dc(b, c), b.parentFlushed && a.completedBoundaries.push(b), b.fallbackAbortableTasks.forEach(Fc, a), b.fallbackAbortableTasks.clear()) : c.parentFlushed && 1 === c.status && (Dc(b, c), 1 === b.completedSegments.length && b.parentFlushed && a.partialBoundaries.push(b)));
+    a.allPendingTasks--;
+    0 === a.allPendingTasks && (a = a.onAllReady, a());
+  }
+  function vc(a) {
+    if (2 !== a.status) {
+      var b = H,
+          c = sc.current;
+      sc.current = rc;
+      var d = V;
+      V = a.responseState;
+      try {
+        var f = a.pingedTasks,
+            e;
+        for (e = 0; e < f.length; e++) {
+          var g = f[e];
+          var h = a,
+              l = g.blockedSegment;
+          if (0 === l.status) {
+            J(g.context);
+            try {
+              Z(h, g, g.node), g.abortSet.delete(g), l.status = 1, Gc(h, g.blockedBoundary, l);
+            } catch (w) {
+              if (lc(), "object" === typeof w && null !== w && "function" === typeof w.then) {
+                var m = g.ping;
+                w.then(m, m);
+              } else {
+                g.abortSet.delete(g);
+                l.status = 4;
+                var n = g.blockedBoundary,
+                    y = w;
+                Y(h, y);
+                null === n ? xc(h, y) : (n.pendingTasks--, n.forceClientRender || (n.forceClientRender = !0, n.parentFlushed && h.clientRenderedBoundaries.push(n)));
+                h.allPendingTasks--;
+                if (0 === h.allPendingTasks) {
+                  var B = h.onAllReady;
+                  B();
+                }
+              }
+            } finally {}
+          }
+        }
+        f.splice(0, e);
+        null !== a.destination && Ic(a, a.destination);
+      } catch (w) {
+        Y(a, w), xc(a, w);
+      } finally {
+        V = d, sc.current = c, c === rc && J(b);
+      }
+    }
+  }
+  function Jc(a, b, c) {
+    c.parentFlushed = !0;
+    switch (c.status) {
+      case 0:
+        var d = c.id = a.nextSegmentId++;
+        a = a.responseState;
+        b.write(Na);
+        b.write(a.placeholderPrefix);
+        a = d.toString(16);
+        b.write(a);
+        return b.write(Oa);
+      case 1:
+        c.status = 2;
+        var f = !0;
+        d = c.chunks;
+        var e = 0;
+        c = c.children;
+        for (var g = 0; g < c.length; g++) {
+          for (f = c[g]; e < f.index; e++)
+            b.write(d[e]);
+          f = Kc(a, b, f);
+        }
+        for (; e < d.length - 1; e++)
+          b.write(d[e]);
+        e < d.length && (f = b.write(d[e]));
+        return f;
+      default:
+        throw Error("Aborted, errored or already flushed boundaries should not be flushed again. This is a bug in React.");
+    }
+  }
+  function Kc(a, b, c) {
+    var d = c.boundary;
+    if (null === d)
+      return Jc(a, b, c);
+    d.parentFlushed = !0;
+    if (d.forceClientRender)
+      b.write(Sa), Jc(a, b, c);
+    else if (0 < d.pendingTasks) {
+      d.rootSegmentID = a.nextSegmentId++;
+      0 < d.completedSegments.length && a.partialBoundaries.push(d);
+      var f = a.responseState;
+      var e = f.nextSuspenseID++;
+      f = k(f.boundaryPrefix + e.toString(16));
+      d = d.id = f;
+      Ua(b, a.responseState, d);
+      Jc(a, b, c);
+    } else if (d.byteSize > a.progressiveChunkSize)
+      d.rootSegmentID = a.nextSegmentId++, a.completedBoundaries.push(d), Ua(b, a.responseState, d.id), Jc(a, b, c);
+    else {
+      b.write(Pa);
+      c = d.completedSegments;
+      if (1 !== c.length)
+        throw Error("A previously unvisited boundary must have exactly one root segment. This is a bug in React.");
+      Kc(a, b, c[0]);
+    }
+    return b.write(Ta);
+  }
+  function Lc(a, b, c) {
+    pb(b, a.responseState, c.formatContext, c.id);
+    Kc(a, b, c);
+    return qb(b, c.formatContext);
+  }
+  function Mc(a, b, c) {
+    for (var d = c.completedSegments,
+        f = 0; f < d.length; f++)
+      Nc(a, b, c, d[f]);
+    d.length = 0;
+    a = a.responseState;
+    d = c.id;
+    c = c.rootSegmentID;
+    b.write(a.startInlineScript);
+    a.sentCompleteBoundaryFunction ? b.write(wb) : (a.sentCompleteBoundaryFunction = !0, b.write(vb));
+    if (null === d)
+      throw Error("An ID must have been assigned before we can complete the boundary.");
+    c = c.toString(16);
+    b.write(d);
+    b.write(xb);
+    b.write(a.segmentPrefix);
+    b.write(c);
+    return b.write(yb);
+  }
+  function Nc(a, b, c, d) {
+    if (2 === d.status)
+      return !0;
+    var f = d.id;
+    if (-1 === f) {
+      if (-1 === (d.id = c.rootSegmentID))
+        throw Error("A root segment ID must have been assigned by now. This is a bug in React.");
+      return Lc(a, b, d);
+    }
+    Lc(a, b, d);
+    a = a.responseState;
+    b.write(a.startInlineScript);
+    a.sentCompleteSegmentFunction ? b.write(sb) : (a.sentCompleteSegmentFunction = !0, b.write(rb));
+    b.write(a.segmentPrefix);
+    f = f.toString(16);
+    b.write(f);
+    b.write(tb);
+    b.write(a.placeholderPrefix);
+    b.write(f);
+    return b.write(ub);
+  }
+  function Ic(a, b) {
+    ba(b);
+    try {
+      var c = a.completedRootSegment;
+      if (null !== c && 0 === a.pendingRootTasks) {
+        Kc(a, b, c);
+        a.completedRootSegment = null;
+        var d = a.responseState.bootstrapChunks;
+        for (c = 0; c < d.length - 1; c++)
+          b.write(d[c]);
+        c < d.length && b.write(d[c]);
+      }
+      var f = a.clientRenderedBoundaries,
+          e;
+      for (e = 0; e < f.length; e++) {
+        d = b;
+        var g = a.responseState,
+            h = f[e].id;
+        d.write(g.startInlineScript);
+        g.sentClientRenderFunction ? d.write(Ab) : (g.sentClientRenderFunction = !0, d.write(zb));
+        if (null === h)
+          throw Error("An ID must have been assigned before we can complete the boundary.");
+        d.write(h);
+        if (!d.write(Bb)) {
+          a.destination = null;
+          e++;
+          f.splice(0, e);
+          return;
+        }
+      }
+      f.splice(0, e);
+      var l = a.completedBoundaries;
+      for (e = 0; e < l.length; e++)
+        if (!Mc(a, b, l[e])) {
+          a.destination = null;
+          e++;
+          l.splice(0, e);
+          return;
+        }
+      l.splice(0, e);
+      ca(b);
+      ba(b);
+      var m = a.partialBoundaries;
+      for (e = 0; e < m.length; e++) {
+        var n = m[e];
+        a: {
+          f = a;
+          g = b;
+          var y = n.completedSegments;
+          for (h = 0; h < y.length; h++)
+            if (!Nc(f, g, n, y[h])) {
+              h++;
+              y.splice(0, h);
+              var B = !1;
+              break a;
+            }
+          y.splice(0, h);
+          B = !0;
+        }
+        if (!B) {
+          a.destination = null;
+          e++;
+          m.splice(0, e);
+          return;
+        }
+      }
+      m.splice(0, e);
+      var w = a.completedBoundaries;
+      for (e = 0; e < w.length; e++)
+        if (!Mc(a, b, w[e])) {
+          a.destination = null;
+          e++;
+          w.splice(0, e);
+          return;
+        }
+      w.splice(0, e);
+    } finally {
+      ca(b), "function" === typeof b.flush && b.flush(), 0 === a.allPendingTasks && 0 === a.pingedTasks.length && 0 === a.clientRenderedBoundaries.length && 0 === a.completedBoundaries.length && b.end();
+    }
+  }
+  function Oc(a) {
+    setImmediate(function() {
+      return vc(a);
+    });
+  }
+  function Pc(a, b) {
+    if (1 === a.status)
+      a.status = 2, b.destroy(a.fatalError);
+    else if (2 !== a.status && null === a.destination) {
+      a.destination = b;
+      try {
+        Ic(a, b);
+      } catch (c) {
+        Y(a, c), xc(a, c);
+      }
+    }
+  }
+  function Qc(a) {
+    try {
+      var b = a.abortableTasks;
+      b.forEach(Hc, a);
+      b.clear();
+      null !== a.destination && Ic(a, a.destination);
+    } catch (c) {
+      Y(a, c), xc(a, c);
+    }
+  }
+  function Rc(a, b) {
+    return function() {
+      return Pc(b, a);
+    };
+  }
+  function Sc(a) {
+    return function() {
+      return Qc(a);
+    };
+  }
+  function Tc(a, b) {
+    var c = b ? b.identifierPrefix : void 0,
+        d = b ? b.nonce : void 0,
+        f = b ? b.bootstrapScriptContent : void 0,
+        e = b ? b.bootstrapScripts : void 0;
+    var g = b ? b.bootstrapModules : void 0;
+    c = void 0 === c ? "" : c;
+    d = void 0 === d ? pa : k('<script nonce="' + u(d) + '">');
+    var h = [];
+    void 0 !== f && h.push(d, u(f), qa);
+    if (void 0 !== e)
+      for (f = 0; f < e.length; f++)
+        h.push(ra, u(e[f]), ta);
+    if (void 0 !== g)
+      for (e = 0; e < g.length; e++)
+        h.push(sa, u(g[e]), ta);
+    g = {
+      bootstrapChunks: h,
+      startInlineScript: d,
+      placeholderPrefix: k(c + "P:"),
+      segmentPrefix: k(c + "S:"),
+      boundaryPrefix: c + "B:",
+      idPrefix: c,
+      nextSuspenseID: 0,
+      sentCompleteSegmentFunction: !1,
+      sentCompleteBoundaryFunction: !1,
+      sentClientRenderFunction: !1
+    };
+    e = b ? b.namespaceURI : void 0;
+    e = v("http://www.w3.org/2000/svg" === e ? 2 : "http://www.w3.org/1998/Math/MathML" === e ? 3 : 0, null);
+    f = b ? b.progressiveChunkSize : void 0;
+    d = b ? b.onError : void 0;
+    h = b ? b.onAllReady : void 0;
+    var l = b ? b.onShellReady : void 0,
+        m = b ? b.onShellError : void 0;
+    b = [];
+    c = new Set;
+    g = {
+      destination: null,
+      responseState: g,
+      progressiveChunkSize: void 0 === f ? 12800 : f,
+      status: 0,
+      fatalError: null,
+      nextSegmentId: 0,
+      allPendingTasks: 0,
+      pendingRootTasks: 0,
+      completedRootSegment: null,
+      abortableTasks: c,
+      pingedTasks: b,
+      clientRenderedBoundaries: [],
+      completedBoundaries: [],
+      partialBoundaries: [],
+      onError: void 0 === d ? tc : d,
+      onAllReady: void 0 === h ? W : h,
+      onShellReady: void 0 === l ? W : l,
+      onShellError: void 0 === m ? W : m,
+      onFatalError: W
+    };
+    e = X(g, 0, null, e);
+    e.parentFlushed = !0;
+    a = wc(g, a, null, e, c, Ub, null, bc);
+    b.push(a);
+    return g;
+  }
+  exports.renderToPipeableStream = function(a, b) {
+    var c = Tc(a, b),
+        d = !1;
+    Oc(c);
+    return {
+      pipe: function(a) {
+        if (d)
+          throw Error("React currently only supports piping to one writable stream.");
+        d = !0;
+        Pc(c, a);
+        a.on("drain", Rc(a, c));
+        a.on("close", Sc(c));
+        return a;
+      },
+      abort: function() {
+        Qc(c);
+      }
+    };
+  };
+  exports.version = "18.0.0-fc46dba67-20220329";
+})(require('buffer').Buffer);