@invoice-sdk/widget 1.5.2 → 1.5.3

package/dist/index.es.js

@@ -0,0 +1,4998 @@
+import * as vr from "react";
+import P, { useRef as ys, useState as Qt, useCallback as gs, useEffect as vs, forwardRef as _s } from "react";
+import { Outlet as bs, useNavigate as nr, BrowserRouter as xs, Routes as ks, Route as We, Navigate as ws } from "react-router-dom";
+var Ot = { exports: {} }, ct = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var _r;
+function Ts() {
+  if (_r) return ct;
+  _r = 1;
+  var t = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function r(s, n, a) {
+    var i = null;
+    if (a !== void 0 && (i = "" + a), n.key !== void 0 && (i = "" + n.key), "key" in n) {
+      a = {};
+      for (var o in n)
+        o !== "key" && (a[o] = n[o]);
+    } else a = n;
+    return n = a.ref, {
+      $$typeof: t,
+      type: s,
+      key: i,
+      ref: n !== void 0 ? n : null,
+      props: a
+    };
+  }
+  return ct.Fragment = e, ct.jsx = r, ct.jsxs = r, ct;
+}
+var lt = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var br;
+function Ss() {
+  return br || (br = 1, process.env.NODE_ENV !== "production" && function() {
+    function t(h) {
+      if (h == null) return null;
+      if (typeof h == "function")
+        return h.$$typeof === Ee ? null : h.displayName || h.name || null;
+      if (typeof h == "string") return h;
+      switch (h) {
+        case Z:
+          return "Fragment";
+        case pe:
+          return "Profiler";
+        case B:
+          return "StrictMode";
+        case q:
+          return "Suspense";
+        case Xe:
+          return "SuspenseList";
+        case le:
+          return "Activity";
+      }
+      if (typeof h == "object")
+        switch (typeof h.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), h.$$typeof) {
+          case te:
+            return "Portal";
+          case ce:
+            return (h.displayName || "Context") + ".Provider";
+          case R:
+            return (h._context.displayName || "Context") + ".Consumer";
+          case re:
+            var C = h.render;
+            return h = h.displayName, h || (h = C.displayName || C.name || "", h = h !== "" ? "ForwardRef(" + h + ")" : "ForwardRef"), h;
+          case xe:
+            return C = h.displayName || null, C !== null ? C : t(h.type) || "Memo";
+          case Qe:
+            C = h._payload, h = h._init;
+            try {
+              return t(h(C));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function e(h) {
+      return "" + h;
+    }
+    function r(h) {
+      try {
+        e(h);
+        var C = !1;
+      } catch {
+        C = !0;
+      }
+      if (C) {
+        C = console;
+        var U = C.error, H = typeof Symbol == "function" && Symbol.toStringTag && h[Symbol.toStringTag] || h.constructor.name || "Object";
+        return U.call(
+          C,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          H
+        ), e(h);
+      }
+    }
+    function s(h) {
+      if (h === Z) return "<>";
+      if (typeof h == "object" && h !== null && h.$$typeof === Qe)
+        return "<...>";
+      try {
+        var C = t(h);
+        return C ? "<" + C + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function n() {
+      var h = oe.A;
+      return h === null ? null : h.getOwner();
+    }
+    function a() {
+      return Error("react-stack-top-frame");
+    }
+    function i(h) {
+      if (V.call(h, "key")) {
+        var C = Object.getOwnPropertyDescriptor(h, "key").get;
+        if (C && C.isReactWarning) return !1;
+      }
+      return h.key !== void 0;
+    }
+    function o(h, C) {
+      function U() {
+        Q || (Q = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          C
+        ));
+      }
+      U.isReactWarning = !0, Object.defineProperty(h, "key", {
+        get: U,
+        configurable: !0
+      });
+    }
+    function d() {
+      var h = t(this.type);
+      return K[h] || (K[h] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), h = this.props.ref, h !== void 0 ? h : null;
+    }
+    function f(h, C, U, H, ke, de, ot, Be) {
+      return U = de.ref, h = {
+        $$typeof: W,
+        type: h,
+        key: C,
+        props: de,
+        _owner: ke
+      }, (U !== void 0 ? U : null) !== null ? Object.defineProperty(h, "ref", {
+        enumerable: !1,
+        get: d
+      }) : Object.defineProperty(h, "ref", { enumerable: !1, value: null }), h._store = {}, Object.defineProperty(h._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(h, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(h, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: ot
+      }), Object.defineProperty(h, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: Be
+      }), Object.freeze && (Object.freeze(h.props), Object.freeze(h)), h;
+    }
+    function _(h, C, U, H, ke, de, ot, Be) {
+      var G = C.children;
+      if (G !== void 0)
+        if (H)
+          if (I(G)) {
+            for (H = 0; H < G.length; H++)
+              y(G[H]);
+            Object.freeze && Object.freeze(G);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else y(G);
+      if (V.call(C, "key")) {
+        G = t(h);
+        var we = Object.keys(C).filter(function(Yt) {
+          return Yt !== "key";
+        });
+        H = 0 < we.length ? "{key: someKey, " + we.join(": ..., ") + ": ...}" : "{key: someKey}", Ne[G + H] || (we = 0 < we.length ? "{" + we.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          H,
+          G,
+          we,
+          G
+        ), Ne[G + H] = !0);
+      }
+      if (G = null, U !== void 0 && (r(U), G = "" + U), i(C) && (r(C.key), G = "" + C.key), "key" in C) {
+        U = {};
+        for (var Ke in C)
+          Ke !== "key" && (U[Ke] = C[Ke]);
+      } else U = C;
+      return G && o(
+        U,
+        typeof h == "function" ? h.displayName || h.name || "Unknown" : h
+      ), f(
+        h,
+        G,
+        de,
+        ke,
+        n(),
+        U,
+        ot,
+        Be
+      );
+    }
+    function y(h) {
+      typeof h == "object" && h !== null && h.$$typeof === W && h._store && (h._store.validated = 1);
+    }
+    var v = P, W = Symbol.for("react.transitional.element"), te = Symbol.for("react.portal"), Z = Symbol.for("react.fragment"), B = Symbol.for("react.strict_mode"), pe = Symbol.for("react.profiler"), R = Symbol.for("react.consumer"), ce = Symbol.for("react.context"), re = Symbol.for("react.forward_ref"), q = Symbol.for("react.suspense"), Xe = Symbol.for("react.suspense_list"), xe = Symbol.for("react.memo"), Qe = Symbol.for("react.lazy"), le = Symbol.for("react.activity"), Ee = Symbol.for("react.client.reference"), oe = v.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, V = Object.prototype.hasOwnProperty, I = Array.isArray, $ = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    v = {
+      "react-stack-bottom-frame": function(h) {
+        return h();
+      }
+    };
+    var Q, K = {}, ue = v["react-stack-bottom-frame"].bind(
+      v,
+      a
+    )(), Pe = $(s(a)), Ne = {};
+    lt.Fragment = Z, lt.jsx = function(h, C, U, H, ke) {
+      var de = 1e4 > oe.recentlyCreatedOwnerStacks++;
+      return _(
+        h,
+        C,
+        U,
+        !1,
+        H,
+        ke,
+        de ? Error("react-stack-top-frame") : ue,
+        de ? $(s(h)) : Pe
+      );
+    }, lt.jsxs = function(h, C, U, H, ke) {
+      var de = 1e4 > oe.recentlyCreatedOwnerStacks++;
+      return _(
+        h,
+        C,
+        U,
+        !0,
+        H,
+        ke,
+        de ? Error("react-stack-top-frame") : ue,
+        de ? $(s(h)) : Pe
+      );
+    };
+  }()), lt;
+}
+var xr;
+function As() {
+  return xr || (xr = 1, process.env.NODE_ENV === "production" ? Ot.exports = Ts() : Ot.exports = Ss()), Ot.exports;
+}
+var p = As();
+const kr = (t) => {
+  let e;
+  const r = /* @__PURE__ */ new Set(), s = (f, _) => {
+    const y = typeof f == "function" ? f(e) : f;
+    if (!Object.is(y, e)) {
+      const v = e;
+      e = _ ?? (typeof y != "object" || y === null) ? y : Object.assign({}, e, y), r.forEach((W) => W(e, v));
+    }
+  }, n = () => e, o = { setState: s, getState: n, getInitialState: () => d, subscribe: (f) => (r.add(f), () => r.delete(f)) }, d = e = t(s, n, o);
+  return o;
+}, js = (t) => t ? kr(t) : kr, Es = (t) => t;
+function Ns(t, e = Es) {
+  const r = P.useSyncExternalStore(
+    t.subscribe,
+    () => e(t.getState()),
+    () => e(t.getInitialState())
+  );
+  return P.useDebugValue(r), r;
+}
+const wr = (t) => {
+  const e = js(t), r = (s) => Ns(e, s);
+  return Object.assign(r, e), r;
+}, Lr = (t) => t ? wr(t) : wr, mt = Lr((t) => ({
+  step: 1,
+  nextStep: () => t((e) => ({ step: e.step + 1 })),
+  prevStep: () => t((e) => ({ step: Math.max(e.step - 1, 1) })),
+  reset: () => t({ step: 1 })
+})), Cs = 4, Rs = () => {
+  const { step: t } = mt();
+  return /* @__PURE__ */ p.jsx("div", { className: "w-full relative h-3 bg-gray-200 rounded-full", children: /* @__PURE__ */ p.jsx(
+    "div",
+    {
+      className: "absolute rounded-full bg-green-500",
+      style: {
+        width: `${t / Cs * 100}%`,
+        height: "100%",
+        transition: "width 0.3s ease-in-out"
+      }
+    }
+  ) });
+}, Os = () => /* @__PURE__ */ p.jsxs("div", { className: "max-w-[800px] mx-auto py-10 flex flex-col gap-8", children: [
+  /* @__PURE__ */ p.jsx(Rs, {}),
+  /* @__PURE__ */ p.jsx(bs, {})
+] });
+var Nt = (t) => t.type === "checkbox", qe = (t) => t instanceof Date, ae = (t) => t == null;
+const $r = (t) => typeof t == "object";
+var J = (t) => !ae(t) && !Array.isArray(t) && $r(t) && !qe(t), Ur = (t) => J(t) && t.target ? Nt(t.target) ? t.target.checked : t.target.value : t, Vs = (t) => t.substring(0, t.search(/\.\d+(\.|$)/)) || t, zr = (t, e) => t.has(Vs(e)), Fs = (t) => {
+  const e = t.constructor && t.constructor.prototype;
+  return J(e) && e.hasOwnProperty("isPrototypeOf");
+}, ar = typeof window < "u" && typeof window.HTMLElement < "u" && typeof document < "u";
+function ee(t) {
+  let e;
+  const r = Array.isArray(t), s = typeof FileList < "u" ? t instanceof FileList : !1;
+  if (t instanceof Date)
+    e = new Date(t);
+  else if (t instanceof Set)
+    e = new Set(t);
+  else if (!(ar && (t instanceof Blob || s)) && (r || J(t)))
+    if (e = r ? [] : {}, !r && !Fs(t))
+      e = t;
+    else
+      for (const n in t)
+        t.hasOwnProperty(n) && (e[n] = ee(t[n]));
+  else
+    return t;
+  return e;
+}
+var Wt = (t) => Array.isArray(t) ? t.filter(Boolean) : [], Y = (t) => t === void 0, x = (t, e, r) => {
+  if (!e || !J(t))
+    return r;
+  const s = Wt(e.split(/[,[\].]+?/)).reduce((n, a) => ae(n) ? n : n[a], t);
+  return Y(s) || s === t ? Y(t[e]) ? r : t[e] : s;
+}, fe = (t) => typeof t == "boolean", ir = (t) => /^\w*$/.test(t), Br = (t) => Wt(t.replace(/["|']|\]/g, "").split(/\.|\[/)), D = (t, e, r) => {
+  let s = -1;
+  const n = ir(e) ? [e] : Br(e), a = n.length, i = a - 1;
+  for (; ++s < a; ) {
+    const o = n[s];
+    let d = r;
+    if (s !== i) {
+      const f = t[o];
+      d = J(f) || Array.isArray(f) ? f : isNaN(+n[s + 1]) ? {} : [];
+    }
+    if (o === "__proto__" || o === "constructor" || o === "prototype")
+      return;
+    t[o] = d, t = t[o];
+  }
+};
+const Ft = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+}, ye = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+}, Ce = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+}, Ps = P.createContext(null), or = () => P.useContext(Ps);
+var Wr = (t, e, r, s = !0) => {
+  const n = {
+    defaultValues: e._defaultValues
+  };
+  for (const a in t)
+    Object.defineProperty(n, a, {
+      get: () => {
+        const i = a;
+        return e._proxyFormState[i] !== ye.all && (e._proxyFormState[i] = !s || ye.all), r && (r[i] = !0), t[i];
+      }
+    });
+  return n;
+};
+const cr = typeof window < "u" ? vr.useLayoutEffect : vr.useEffect;
+function Is(t) {
+  const e = or(), { control: r = e.control, disabled: s, name: n, exact: a } = t || {}, [i, o] = P.useState(r._formState), d = P.useRef({
+    isDirty: !1,
+    isLoading: !1,
+    dirtyFields: !1,
+    touchedFields: !1,
+    validatingFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  });
+  return cr(() => r._subscribe({
+    name: n,
+    formState: d.current,
+    exact: a,
+    callback: (f) => {
+      !s && o({
+        ...r._formState,
+        ...f
+      });
+    }
+  }), [n, s, a]), P.useEffect(() => {
+    d.current.isValid && r._setValid(!0);
+  }, [r]), P.useMemo(() => Wr(i, r, d.current, !1), [i, r]);
+}
+var Te = (t) => typeof t == "string", qr = (t, e, r, s, n) => Te(t) ? (s && e.watch.add(t), x(r, t, n)) : Array.isArray(t) ? t.map((a) => (s && e.watch.add(a), x(r, a))) : (s && (e.watchAll = !0), r);
+function Ds(t) {
+  const e = or(), { control: r = e.control, name: s, defaultValue: n, disabled: a, exact: i } = t || {}, o = P.useRef(n), [d, f] = P.useState(r._getWatch(s, o.current));
+  return cr(() => r._subscribe({
+    name: s,
+    formState: {
+      values: !0
+    },
+    exact: i,
+    callback: (_) => !a && f(qr(s, r._names, _.values || r._formValues, !1, o.current))
+  }), [s, r, a, i]), P.useEffect(() => r._removeUnmounted()), d;
+}
+function Ms(t) {
+  const e = or(), { name: r, disabled: s, control: n = e.control, shouldUnregister: a } = t, i = zr(n._names.array, r), o = Ds({
+    control: n,
+    name: r,
+    defaultValue: x(n._formValues, r, x(n._defaultValues, r, t.defaultValue)),
+    exact: !0
+  }), d = Is({
+    control: n,
+    name: r,
+    exact: !0
+  }), f = P.useRef(t), _ = P.useRef(n.register(r, {
+    ...t.rules,
+    value: o,
+    ...fe(t.disabled) ? { disabled: t.disabled } : {}
+  })), y = P.useMemo(() => Object.defineProperties({}, {
+    invalid: {
+      enumerable: !0,
+      get: () => !!x(d.errors, r)
+    },
+    isDirty: {
+      enumerable: !0,
+      get: () => !!x(d.dirtyFields, r)
+    },
+    isTouched: {
+      enumerable: !0,
+      get: () => !!x(d.touchedFields, r)
+    },
+    isValidating: {
+      enumerable: !0,
+      get: () => !!x(d.validatingFields, r)
+    },
+    error: {
+      enumerable: !0,
+      get: () => x(d.errors, r)
+    }
+  }), [d, r]), v = P.useCallback((B) => _.current.onChange({
+    target: {
+      value: Ur(B),
+      name: r
+    },
+    type: Ft.CHANGE
+  }), [r]), W = P.useCallback(() => _.current.onBlur({
+    target: {
+      value: x(n._formValues, r),
+      name: r
+    },
+    type: Ft.BLUR
+  }), [r, n._formValues]), te = P.useCallback((B) => {
+    const pe = x(n._fields, r);
+    pe && B && (pe._f.ref = {
+      focus: () => B.focus(),
+      select: () => B.select(),
+      setCustomValidity: (R) => B.setCustomValidity(R),
+      reportValidity: () => B.reportValidity()
+    });
+  }, [n._fields, r]), Z = P.useMemo(() => ({
+    name: r,
+    value: o,
+    ...fe(s) || d.disabled ? { disabled: d.disabled || s } : {},
+    onChange: v,
+    onBlur: W,
+    ref: te
+  }), [r, s, d.disabled, v, W, te, o]);
+  return P.useEffect(() => {
+    const B = n._options.shouldUnregister || a;
+    n.register(r, {
+      ...f.current.rules,
+      ...fe(f.current.disabled) ? { disabled: f.current.disabled } : {}
+    });
+    const pe = (R, ce) => {
+      const re = x(n._fields, R);
+      re && re._f && (re._f.mount = ce);
+    };
+    if (pe(r, !0), B) {
+      const R = ee(x(n._options.defaultValues, r));
+      D(n._defaultValues, r, R), Y(x(n._formValues, r)) && D(n._formValues, r, R);
+    }
+    return !i && n.register(r), () => {
+      (i ? B && !n._state.action : B) ? n.unregister(r) : pe(r, !1);
+    };
+  }, [r, n, i, a]), P.useEffect(() => {
+    n._setDisabledField({
+      disabled: s,
+      name: r
+    });
+  }, [s, r, n]), P.useMemo(() => ({
+    field: Z,
+    formState: d,
+    fieldState: y
+  }), [Z, d, y]);
+}
+const De = (t) => t.render(Ms(t));
+var Yr = (t, e, r, s, n) => e ? {
+  ...r[t],
+  types: {
+    ...r[t] && r[t].types ? r[t].types : {},
+    [s]: n || !0
+  }
+} : {}, ft = (t) => Array.isArray(t) ? t : [t], Tr = () => {
+  let t = [];
+  return {
+    get observers() {
+      return t;
+    },
+    next: (n) => {
+      for (const a of t)
+        a.next && a.next(n);
+    },
+    subscribe: (n) => (t.push(n), {
+      unsubscribe: () => {
+        t = t.filter((a) => a !== n);
+      }
+    }),
+    unsubscribe: () => {
+      t = [];
+    }
+  };
+}, Kt = (t) => ae(t) || !$r(t);
+function Ze(t, e) {
+  if (Kt(t) || Kt(e))
+    return t === e;
+  if (qe(t) && qe(e))
+    return t.getTime() === e.getTime();
+  const r = Object.keys(t), s = Object.keys(e);
+  if (r.length !== s.length)
+    return !1;
+  for (const n of r) {
+    const a = t[n];
+    if (!s.includes(n))
+      return !1;
+    if (n !== "ref") {
+      const i = e[n];
+      if (qe(a) && qe(i) || J(a) && J(i) || Array.isArray(a) && Array.isArray(i) ? !Ze(a, i) : a !== i)
+        return !1;
+    }
+  }
+  return !0;
+}
+var ne = (t) => J(t) && !Object.keys(t).length, lr = (t) => t.type === "file", ge = (t) => typeof t == "function", Pt = (t) => {
+  if (!ar)
+    return !1;
+  const e = t ? t.ownerDocument : 0;
+  return t instanceof (e && e.defaultView ? e.defaultView.HTMLElement : HTMLElement);
+}, Jr = (t) => t.type === "select-multiple", ur = (t) => t.type === "radio", Zs = (t) => ur(t) || Nt(t), Gt = (t) => Pt(t) && t.isConnected;
+function Ls(t, e) {
+  const r = e.slice(0, -1).length;
+  let s = 0;
+  for (; s < r; )
+    t = Y(t) ? s++ : t[e[s++]];
+  return t;
+}
+function $s(t) {
+  for (const e in t)
+    if (t.hasOwnProperty(e) && !Y(t[e]))
+      return !1;
+  return !0;
+}
+function X(t, e) {
+  const r = Array.isArray(e) ? e : ir(e) ? [e] : Br(e), s = r.length === 1 ? t : Ls(t, r), n = r.length - 1, a = r[n];
+  return s && delete s[a], n !== 0 && (J(s) && ne(s) || Array.isArray(s) && $s(s)) && X(t, r.slice(0, -1)), t;
+}
+var Hr = (t) => {
+  for (const e in t)
+    if (ge(t[e]))
+      return !0;
+  return !1;
+};
+function It(t, e = {}) {
+  const r = Array.isArray(t);
+  if (J(t) || r)
+    for (const s in t)
+      Array.isArray(t[s]) || J(t[s]) && !Hr(t[s]) ? (e[s] = Array.isArray(t[s]) ? [] : {}, It(t[s], e[s])) : ae(t[s]) || (e[s] = !0);
+  return e;
+}
+function Gr(t, e, r) {
+  const s = Array.isArray(t);
+  if (J(t) || s)
+    for (const n in t)
+      Array.isArray(t[n]) || J(t[n]) && !Hr(t[n]) ? Y(e) || Kt(r[n]) ? r[n] = Array.isArray(t[n]) ? It(t[n], []) : { ...It(t[n]) } : Gr(t[n], ae(e) ? {} : e[n], r[n]) : r[n] = !Ze(t[n], e[n]);
+  return r;
+}
+var ut = (t, e) => Gr(t, e, It(e));
+const Sr = {
+  value: !1,
+  isValid: !1
+}, Ar = { value: !0, isValid: !0 };
+var Xr = (t) => {
+  if (Array.isArray(t)) {
+    if (t.length > 1) {
+      const e = t.filter((r) => r && r.checked && !r.disabled).map((r) => r.value);
+      return { value: e, isValid: !!e.length };
+    }
+    return t[0].checked && !t[0].disabled ? (
+      // @ts-expect-error expected to work in the browser
+      t[0].attributes && !Y(t[0].attributes.value) ? Y(t[0].value) || t[0].value === "" ? Ar : { value: t[0].value, isValid: !0 } : Ar
+    ) : Sr;
+  }
+  return Sr;
+}, Qr = (t, { valueAsNumber: e, valueAsDate: r, setValueAs: s }) => Y(t) ? t : e ? t === "" ? NaN : t && +t : r && Te(t) ? new Date(t) : s ? s(t) : t;
+const jr = {
+  isValid: !1,
+  value: null
+};
+var Kr = (t) => Array.isArray(t) ? t.reduce((e, r) => r && r.checked && !r.disabled ? {
+  isValid: !0,
+  value: r.value
+} : e, jr) : jr;
+function Er(t) {
+  const e = t.ref;
+  return lr(e) ? e.files : ur(e) ? Kr(t.refs).value : Jr(e) ? [...e.selectedOptions].map(({ value: r }) => r) : Nt(e) ? Xr(t.refs).value : Qr(Y(e.value) ? t.ref.value : e.value, t);
+}
+var Us = (t, e, r, s) => {
+  const n = {};
+  for (const a of t) {
+    const i = x(e, a);
+    i && D(n, a, i._f);
+  }
+  return {
+    criteriaMode: r,
+    names: [...t],
+    fields: n,
+    shouldUseNativeValidation: s
+  };
+}, Dt = (t) => t instanceof RegExp, dt = (t) => Y(t) ? t : Dt(t) ? t.source : J(t) ? Dt(t.value) ? t.value.source : t.value : t, Nr = (t) => ({
+  isOnSubmit: !t || t === ye.onSubmit,
+  isOnBlur: t === ye.onBlur,
+  isOnChange: t === ye.onChange,
+  isOnAll: t === ye.all,
+  isOnTouch: t === ye.onTouched
+});
+const Cr = "AsyncFunction";
+var zs = (t) => !!t && !!t.validate && !!(ge(t.validate) && t.validate.constructor.name === Cr || J(t.validate) && Object.values(t.validate).find((e) => e.constructor.name === Cr)), Bs = (t) => t.mount && (t.required || t.min || t.max || t.maxLength || t.minLength || t.pattern || t.validate), Rr = (t, e, r) => !r && (e.watchAll || e.watch.has(t) || [...e.watch].some((s) => t.startsWith(s) && /^\.\w+/.test(t.slice(s.length))));
+const ht = (t, e, r, s) => {
+  for (const n of r || Object.keys(t)) {
+    const a = x(t, n);
+    if (a) {
+      const { _f: i, ...o } = a;
+      if (i) {
+        if (i.refs && i.refs[0] && e(i.refs[0], n) && !s)
+          return !0;
+        if (i.ref && e(i.ref, i.name) && !s)
+          return !0;
+        if (ht(o, e))
+          break;
+      } else if (J(o) && ht(o, e))
+        break;
+    }
+  }
+};
+function Or(t, e, r) {
+  const s = x(t, r);
+  if (s || ir(r))
+    return {
+      error: s,
+      name: r
+    };
+  const n = r.split(".");
+  for (; n.length; ) {
+    const a = n.join("."), i = x(e, a), o = x(t, a);
+    if (i && !Array.isArray(i) && r !== a)
+      return { name: r };
+    if (o && o.type)
+      return {
+        name: a,
+        error: o
+      };
+    n.pop();
+  }
+  return {
+    name: r
+  };
+}
+var Ws = (t, e, r, s) => {
+  r(t);
+  const { name: n, ...a } = t;
+  return ne(a) || Object.keys(a).length >= Object.keys(e).length || Object.keys(a).find((i) => e[i] === (!s || ye.all));
+}, qs = (t, e, r) => !t || !e || t === e || ft(t).some((s) => s && (r ? s === e : s.startsWith(e) || e.startsWith(s))), Ys = (t, e, r, s, n) => n.isOnAll ? !1 : !r && n.isOnTouch ? !(e || t) : (r ? s.isOnBlur : n.isOnBlur) ? !t : (r ? s.isOnChange : n.isOnChange) ? t : !0, Js = (t, e) => !Wt(x(t, e)).length && X(t, e), Hs = (t, e, r) => {
+  const s = ft(x(t, r));
+  return D(s, "root", e[r]), D(t, r, s), t;
+}, Vt = (t) => Te(t);
+function Vr(t, e, r = "validate") {
+  if (Vt(t) || Array.isArray(t) && t.every(Vt) || fe(t) && !t)
+    return {
+      type: r,
+      message: Vt(t) ? t : "",
+      ref: e
+    };
+}
+var et = (t) => J(t) && !Dt(t) ? t : {
+  value: t,
+  message: ""
+}, Fr = async (t, e, r, s, n, a) => {
+  const { ref: i, refs: o, required: d, maxLength: f, minLength: _, min: y, max: v, pattern: W, validate: te, name: Z, valueAsNumber: B, mount: pe } = t._f, R = x(r, Z);
+  if (!pe || e.has(Z))
+    return {};
+  const ce = o ? o[0] : i, re = (V) => {
+    n && ce.reportValidity && (ce.setCustomValidity(fe(V) ? "" : V || ""), ce.reportValidity());
+  }, q = {}, Xe = ur(i), xe = Nt(i), Qe = Xe || xe, le = (B || lr(i)) && Y(i.value) && Y(R) || Pt(i) && i.value === "" || R === "" || Array.isArray(R) && !R.length, Ee = Yr.bind(null, Z, s, q), oe = (V, I, $, Q = Ce.maxLength, K = Ce.minLength) => {
+    const ue = V ? I : $;
+    q[Z] = {
+      type: V ? Q : K,
+      message: ue,
+      ref: i,
+      ...Ee(V ? Q : K, ue)
+    };
+  };
+  if (a ? !Array.isArray(R) || !R.length : d && (!Qe && (le || ae(R)) || fe(R) && !R || xe && !Xr(o).isValid || Xe && !Kr(o).isValid)) {
+    const { value: V, message: I } = Vt(d) ? { value: !!d, message: d } : et(d);
+    if (V && (q[Z] = {
+      type: Ce.required,
+      message: I,
+      ref: ce,
+      ...Ee(Ce.required, I)
+    }, !s))
+      return re(I), q;
+  }
+  if (!le && (!ae(y) || !ae(v))) {
+    let V, I;
+    const $ = et(v), Q = et(y);
+    if (!ae(R) && !isNaN(R)) {
+      const K = i.valueAsNumber || R && +R;
+      ae($.value) || (V = K > $.value), ae(Q.value) || (I = K < Q.value);
+    } else {
+      const K = i.valueAsDate || new Date(R), ue = (h) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + h), Pe = i.type == "time", Ne = i.type == "week";
+      Te($.value) && R && (V = Pe ? ue(R) > ue($.value) : Ne ? R > $.value : K > new Date($.value)), Te(Q.value) && R && (I = Pe ? ue(R) < ue(Q.value) : Ne ? R < Q.value : K < new Date(Q.value));
+    }
+    if ((V || I) && (oe(!!V, $.message, Q.message, Ce.max, Ce.min), !s))
+      return re(q[Z].message), q;
+  }
+  if ((f || _) && !le && (Te(R) || a && Array.isArray(R))) {
+    const V = et(f), I = et(_), $ = !ae(V.value) && R.length > +V.value, Q = !ae(I.value) && R.length < +I.value;
+    if (($ || Q) && (oe($, V.message, I.message), !s))
+      return re(q[Z].message), q;
+  }
+  if (W && !le && Te(R)) {
+    const { value: V, message: I } = et(W);
+    if (Dt(V) && !R.match(V) && (q[Z] = {
+      type: Ce.pattern,
+      message: I,
+      ref: i,
+      ...Ee(Ce.pattern, I)
+    }, !s))
+      return re(I), q;
+  }
+  if (te) {
+    if (ge(te)) {
+      const V = await te(R, r), I = Vr(V, ce);
+      if (I && (q[Z] = {
+        ...I,
+        ...Ee(Ce.validate, I.message)
+      }, !s))
+        return re(I.message), q;
+    } else if (J(te)) {
+      let V = {};
+      for (const I in te) {
+        if (!ne(V) && !s)
+          break;
+        const $ = Vr(await te[I](R, r), ce, I);
+        $ && (V = {
+          ...$,
+          ...Ee(I, $.message)
+        }, re($.message), s && (q[Z] = V));
+      }
+      if (!ne(V) && (q[Z] = {
+        ref: ce,
+        ...V
+      }, !s))
+        return q;
+    }
+  }
+  return re(!0), q;
+};
+const Gs = {
+  mode: ye.onSubmit,
+  reValidateMode: ye.onChange,
+  shouldFocusError: !0
+};
+function Xs(t = {}) {
+  let e = {
+    ...Gs,
+    ...t
+  }, r = {
+    submitCount: 0,
+    isDirty: !1,
+    isReady: !1,
+    isLoading: ge(e.defaultValues),
+    isValidating: !1,
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    touchedFields: {},
+    dirtyFields: {},
+    validatingFields: {},
+    errors: e.errors || {},
+    disabled: e.disabled || !1
+  };
+  const s = {};
+  let n = J(e.defaultValues) || J(e.values) ? ee(e.defaultValues || e.values) || {} : {}, a = e.shouldUnregister ? {} : ee(n), i = {
+    action: !1,
+    mount: !1,
+    watch: !1
+  }, o = {
+    mount: /* @__PURE__ */ new Set(),
+    disabled: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  }, d, f = 0;
+  const _ = {
+    isDirty: !1,
+    dirtyFields: !1,
+    validatingFields: !1,
+    touchedFields: !1,
+    isValidating: !1,
+    isValid: !1,
+    errors: !1
+  };
+  let y = {
+    ..._
+  };
+  const v = {
+    array: Tr(),
+    state: Tr()
+  }, W = e.criteriaMode === ye.all, te = (c) => (l) => {
+    clearTimeout(f), f = setTimeout(c, l);
+  }, Z = async (c) => {
+    if (!e.disabled && (_.isValid || y.isValid || c)) {
+      const l = e.resolver ? ne((await xe()).errors) : await le(s, !0);
+      l !== r.isValid && v.state.next({
+        isValid: l
+      });
+    }
+  }, B = (c, l) => {
+    !e.disabled && (_.isValidating || _.validatingFields || y.isValidating || y.validatingFields) && ((c || Array.from(o.mount)).forEach((u) => {
+      u && (l ? D(r.validatingFields, u, l) : X(r.validatingFields, u));
+    }), v.state.next({
+      validatingFields: r.validatingFields,
+      isValidating: !ne(r.validatingFields)
+    }));
+  }, pe = (c, l = [], u, w, b = !0, g = !0) => {
+    if (w && u && !e.disabled) {
+      if (i.action = !0, g && Array.isArray(x(s, c))) {
+        const A = u(x(s, c), w.argA, w.argB);
+        b && D(s, c, A);
+      }
+      if (g && Array.isArray(x(r.errors, c))) {
+        const A = u(x(r.errors, c), w.argA, w.argB);
+        b && D(r.errors, c, A), Js(r.errors, c);
+      }
+      if ((_.touchedFields || y.touchedFields) && g && Array.isArray(x(r.touchedFields, c))) {
+        const A = u(x(r.touchedFields, c), w.argA, w.argB);
+        b && D(r.touchedFields, c, A);
+      }
+      (_.dirtyFields || y.dirtyFields) && (r.dirtyFields = ut(n, a)), v.state.next({
+        name: c,
+        isDirty: oe(c, l),
+        dirtyFields: r.dirtyFields,
+        errors: r.errors,
+        isValid: r.isValid
+      });
+    } else
+      D(a, c, l);
+  }, R = (c, l) => {
+    D(r.errors, c, l), v.state.next({
+      errors: r.errors
+    });
+  }, ce = (c) => {
+    r.errors = c, v.state.next({
+      errors: r.errors,
+      isValid: !1
+    });
+  }, re = (c, l, u, w) => {
+    const b = x(s, c);
+    if (b) {
+      const g = x(a, c, Y(u) ? x(n, c) : u);
+      Y(g) || w && w.defaultChecked || l ? D(a, c, l ? g : Er(b._f)) : $(c, g), i.mount && Z();
+    }
+  }, q = (c, l, u, w, b) => {
+    let g = !1, A = !1;
+    const M = {
+      name: c
+    };
+    if (!e.disabled) {
+      if (!u || w) {
+        (_.isDirty || y.isDirty) && (A = r.isDirty, r.isDirty = M.isDirty = oe(), g = A !== M.isDirty);
+        const L = Ze(x(n, c), l);
+        A = !!x(r.dirtyFields, c), L ? X(r.dirtyFields, c) : D(r.dirtyFields, c, !0), M.dirtyFields = r.dirtyFields, g = g || (_.dirtyFields || y.dirtyFields) && A !== !L;
+      }
+      if (u) {
+        const L = x(r.touchedFields, c);
+        L || (D(r.touchedFields, c, u), M.touchedFields = r.touchedFields, g = g || (_.touchedFields || y.touchedFields) && L !== u);
+      }
+      g && b && v.state.next(M);
+    }
+    return g ? M : {};
+  }, Xe = (c, l, u, w) => {
+    const b = x(r.errors, c), g = (_.isValid || y.isValid) && fe(l) && r.isValid !== l;
+    if (e.delayError && u ? (d = te(() => R(c, u)), d(e.delayError)) : (clearTimeout(f), d = null, u ? D(r.errors, c, u) : X(r.errors, c)), (u ? !Ze(b, u) : b) || !ne(w) || g) {
+      const A = {
+        ...w,
+        ...g && fe(l) ? { isValid: l } : {},
+        errors: r.errors,
+        name: c
+      };
+      r = {
+        ...r,
+        ...A
+      }, v.state.next(A);
+    }
+  }, xe = async (c) => {
+    B(c, !0);
+    const l = await e.resolver(a, e.context, Us(c || o.mount, s, e.criteriaMode, e.shouldUseNativeValidation));
+    return B(c), l;
+  }, Qe = async (c) => {
+    const { errors: l } = await xe(c);
+    if (c)
+      for (const u of c) {
+        const w = x(l, u);
+        w ? D(r.errors, u, w) : X(r.errors, u);
+      }
+    else
+      r.errors = l;
+    return l;
+  }, le = async (c, l, u = {
+    valid: !0
+  }) => {
+    for (const w in c) {
+      const b = c[w];
+      if (b) {
+        const { _f: g, ...A } = b;
+        if (g) {
+          const M = o.array.has(g.name), L = b._f && zs(b._f);
+          L && _.validatingFields && B([w], !0);
+          const me = await Fr(b, o.disabled, a, W, e.shouldUseNativeValidation && !l, M);
+          if (L && _.validatingFields && B([w]), me[g.name] && (u.valid = !1, l))
+            break;
+          !l && (x(me, g.name) ? M ? Hs(r.errors, me, g.name) : D(r.errors, g.name, me[g.name]) : X(r.errors, g.name));
+        }
+        !ne(A) && await le(A, l, u);
+      }
+    }
+    return u.valid;
+  }, Ee = () => {
+    for (const c of o.unMount) {
+      const l = x(s, c);
+      l && (l._f.refs ? l._f.refs.every((u) => !Gt(u)) : !Gt(l._f.ref)) && Be(c);
+    }
+    o.unMount = /* @__PURE__ */ new Set();
+  }, oe = (c, l) => !e.disabled && (c && l && D(a, c, l), !Ze(h(), n)), V = (c, l, u) => qr(c, o, {
+    ...i.mount ? a : Y(l) ? n : Te(c) ? { [c]: l } : l
+  }, u, l), I = (c) => Wt(x(i.mount ? a : n, c, e.shouldUnregister ? x(n, c, []) : [])), $ = (c, l, u = {}) => {
+    const w = x(s, c);
+    let b = l;
+    if (w) {
+      const g = w._f;
+      g && (!g.disabled && D(a, c, Qr(l, g)), b = Pt(g.ref) && ae(l) ? "" : l, Jr(g.ref) ? [...g.ref.options].forEach((A) => A.selected = b.includes(A.value)) : g.refs ? Nt(g.ref) ? g.refs.forEach((A) => {
+        (!A.defaultChecked || !A.disabled) && (Array.isArray(b) ? A.checked = !!b.find((M) => M === A.value) : A.checked = b === A.value || !!b);
+      }) : g.refs.forEach((A) => A.checked = A.value === b) : lr(g.ref) ? g.ref.value = "" : (g.ref.value = b, g.ref.type || v.state.next({
+        name: c,
+        values: ee(a)
+      })));
+    }
+    (u.shouldDirty || u.shouldTouch) && q(c, b, u.shouldTouch, u.shouldDirty, !0), u.shouldValidate && Ne(c);
+  }, Q = (c, l, u) => {
+    for (const w in l) {
+      if (!l.hasOwnProperty(w))
+        return;
+      const b = l[w], g = `${c}.${w}`, A = x(s, g);
+      (o.array.has(c) || J(b) || A && !A._f) && !qe(b) ? Q(g, b, u) : $(g, b, u);
+    }
+  }, K = (c, l, u = {}) => {
+    const w = x(s, c), b = o.array.has(c), g = ee(l);
+    D(a, c, g), b ? (v.array.next({
+      name: c,
+      values: ee(a)
+    }), (_.isDirty || _.dirtyFields || y.isDirty || y.dirtyFields) && u.shouldDirty && v.state.next({
+      name: c,
+      dirtyFields: ut(n, a),
+      isDirty: oe(c, g)
+    })) : w && !w._f && !ae(g) ? Q(c, g, u) : $(c, g, u), Rr(c, o) && v.state.next({ ...r }), v.state.next({
+      name: i.mount ? c : void 0,
+      values: ee(a)
+    });
+  }, ue = async (c) => {
+    i.mount = !0;
+    const l = c.target;
+    let u = l.name, w = !0;
+    const b = x(s, u), g = (L) => {
+      w = Number.isNaN(L) || qe(L) && isNaN(L.getTime()) || Ze(L, x(a, u, L));
+    }, A = Nr(e.mode), M = Nr(e.reValidateMode);
+    if (b) {
+      let L, me;
+      const Rt = l.type ? Er(b._f) : Ur(c), Ie = c.type === Ft.BLUR || c.type === Ft.FOCUS_OUT, hs = !Bs(b._f) && !e.resolver && !x(r.errors, u) && !b._f.deps || Ys(Ie, x(r.touchedFields, u), r.isSubmitted, M, A), Jt = Rr(u, o, Ie);
+      D(a, u, Rt), Ie ? (b._f.onBlur && b._f.onBlur(c), d && d(0)) : b._f.onChange && b._f.onChange(c);
+      const Ht = q(u, Rt, Ie), ms = !ne(Ht) || Jt;
+      if (!Ie && v.state.next({
+        name: u,
+        type: c.type,
+        values: ee(a)
+      }), hs)
+        return (_.isValid || y.isValid) && (e.mode === "onBlur" ? Ie && Z() : Ie || Z()), ms && v.state.next({ name: u, ...Jt ? {} : Ht });
+      if (!Ie && Jt && v.state.next({ ...r }), e.resolver) {
+        const { errors: yr } = await xe([u]);
+        if (g(Rt), w) {
+          const ps = Or(r.errors, s, u), gr = Or(yr, s, ps.name || u);
+          L = gr.error, u = gr.name, me = ne(yr);
+        }
+      } else
+        B([u], !0), L = (await Fr(b, o.disabled, a, W, e.shouldUseNativeValidation))[u], B([u]), g(Rt), w && (L ? me = !1 : (_.isValid || y.isValid) && (me = await le(s, !0)));
+      w && (b._f.deps && Ne(b._f.deps), Xe(u, me, L, Ht));
+    }
+  }, Pe = (c, l) => {
+    if (x(r.errors, l) && c.focus)
+      return c.focus(), 1;
+  }, Ne = async (c, l = {}) => {
+    let u, w;
+    const b = ft(c);
+    if (e.resolver) {
+      const g = await Qe(Y(c) ? c : b);
+      u = ne(g), w = c ? !b.some((A) => x(g, A)) : u;
+    } else c ? (w = (await Promise.all(b.map(async (g) => {
+      const A = x(s, g);
+      return await le(A && A._f ? { [g]: A } : A);
+    }))).every(Boolean), !(!w && !r.isValid) && Z()) : w = u = await le(s);
+    return v.state.next({
+      ...!Te(c) || (_.isValid || y.isValid) && u !== r.isValid ? {} : { name: c },
+      ...e.resolver || !c ? { isValid: u } : {},
+      errors: r.errors
+    }), l.shouldFocus && !w && ht(s, Pe, c ? b : o.mount), w;
+  }, h = (c) => {
+    const l = {
+      ...i.mount ? a : n
+    };
+    return Y(c) ? l : Te(c) ? x(l, c) : c.map((u) => x(l, u));
+  }, C = (c, l) => ({
+    invalid: !!x((l || r).errors, c),
+    isDirty: !!x((l || r).dirtyFields, c),
+    error: x((l || r).errors, c),
+    isValidating: !!x(r.validatingFields, c),
+    isTouched: !!x((l || r).touchedFields, c)
+  }), U = (c) => {
+    c && ft(c).forEach((l) => X(r.errors, l)), v.state.next({
+      errors: c ? r.errors : {}
+    });
+  }, H = (c, l, u) => {
+    const w = (x(s, c, { _f: {} })._f || {}).ref, b = x(r.errors, c) || {}, { ref: g, message: A, type: M, ...L } = b;
+    D(r.errors, c, {
+      ...L,
+      ...l,
+      ref: w
+    }), v.state.next({
+      name: c,
+      errors: r.errors,
+      isValid: !1
+    }), u && u.shouldFocus && w && w.focus && w.focus();
+  }, ke = (c, l) => ge(c) ? v.state.subscribe({
+    next: (u) => c(V(void 0, l), u)
+  }) : V(c, l, !0), de = (c) => v.state.subscribe({
+    next: (l) => {
+      qs(c.name, l.name, c.exact) && Ws(l, c.formState || _, fs, c.reRenderRoot) && c.callback({
+        values: { ...a },
+        ...r,
+        ...l
+      });
+    }
+  }).unsubscribe, ot = (c) => (i.mount = !0, y = {
+    ...y,
+    ...c.formState
+  }, de({
+    ...c,
+    formState: y
+  })), Be = (c, l = {}) => {
+    for (const u of c ? ft(c) : o.mount)
+      o.mount.delete(u), o.array.delete(u), l.keepValue || (X(s, u), X(a, u)), !l.keepError && X(r.errors, u), !l.keepDirty && X(r.dirtyFields, u), !l.keepTouched && X(r.touchedFields, u), !l.keepIsValidating && X(r.validatingFields, u), !e.shouldUnregister && !l.keepDefaultValue && X(n, u);
+    v.state.next({
+      values: ee(a)
+    }), v.state.next({
+      ...r,
+      ...l.keepDirty ? { isDirty: oe() } : {}
+    }), !l.keepIsValid && Z();
+  }, G = ({ disabled: c, name: l }) => {
+    (fe(c) && i.mount || c || o.disabled.has(l)) && (c ? o.disabled.add(l) : o.disabled.delete(l));
+  }, we = (c, l = {}) => {
+    let u = x(s, c);
+    const w = fe(l.disabled) || fe(e.disabled);
+    return D(s, c, {
+      ...u || {},
+      _f: {
+        ...u && u._f ? u._f : { ref: { name: c } },
+        name: c,
+        mount: !0,
+        ...l
+      }
+    }), o.mount.add(c), u ? G({
+      disabled: fe(l.disabled) ? l.disabled : e.disabled,
+      name: c
+    }) : re(c, !0, l.value), {
+      ...w ? { disabled: l.disabled || e.disabled } : {},
+      ...e.progressive ? {
+        required: !!l.required,
+        min: dt(l.min),
+        max: dt(l.max),
+        minLength: dt(l.minLength),
+        maxLength: dt(l.maxLength),
+        pattern: dt(l.pattern)
+      } : {},
+      name: c,
+      onChange: ue,
+      onBlur: ue,
+      ref: (b) => {
+        if (b) {
+          we(c, l), u = x(s, c);
+          const g = Y(b.value) && b.querySelectorAll && b.querySelectorAll("input,select,textarea")[0] || b, A = Zs(g), M = u._f.refs || [];
+          if (A ? M.find((L) => L === g) : g === u._f.ref)
+            return;
+          D(s, c, {
+            _f: {
+              ...u._f,
+              ...A ? {
+                refs: [
+                  ...M.filter(Gt),
+                  g,
+                  ...Array.isArray(x(n, c)) ? [{}] : []
+                ],
+                ref: { type: g.type, name: c }
+              } : { ref: g }
+            }
+          }), re(c, !1, void 0, g);
+        } else
+          u = x(s, c, {}), u._f && (u._f.mount = !1), (e.shouldUnregister || l.shouldUnregister) && !(zr(o.array, c) && i.action) && o.unMount.add(c);
+      }
+    };
+  }, Ke = () => e.shouldFocusError && ht(s, Pe, o.mount), Yt = (c) => {
+    fe(c) && (v.state.next({ disabled: c }), ht(s, (l, u) => {
+      const w = x(s, u);
+      w && (l.disabled = w._f.disabled || c, Array.isArray(w._f.refs) && w._f.refs.forEach((b) => {
+        b.disabled = w._f.disabled || c;
+      }));
+    }, 0, !1));
+  }, fr = (c, l) => async (u) => {
+    let w;
+    u && (u.preventDefault && u.preventDefault(), u.persist && u.persist());
+    let b = ee(a);
+    if (v.state.next({
+      isSubmitting: !0
+    }), e.resolver) {
+      const { errors: g, values: A } = await xe();
+      r.errors = g, b = A;
+    } else
+      await le(s);
+    if (o.disabled.size)
+      for (const g of o.disabled)
+        D(b, g, void 0);
+    if (X(r.errors, "root"), ne(r.errors)) {
+      v.state.next({
+        errors: {}
+      });
+      try {
+        await c(b, u);
+      } catch (g) {
+        w = g;
+      }
+    } else
+      l && await l({ ...r.errors }, u), Ke(), setTimeout(Ke);
+    if (v.state.next({
+      isSubmitted: !0,
+      isSubmitting: !1,
+      isSubmitSuccessful: ne(r.errors) && !w,
+      submitCount: r.submitCount + 1,
+      errors: r.errors
+    }), w)
+      throw w;
+  }, us = (c, l = {}) => {
+    x(s, c) && (Y(l.defaultValue) ? K(c, ee(x(n, c))) : (K(c, l.defaultValue), D(n, c, ee(l.defaultValue))), l.keepTouched || X(r.touchedFields, c), l.keepDirty || (X(r.dirtyFields, c), r.isDirty = l.defaultValue ? oe(c, ee(x(n, c))) : oe()), l.keepError || (X(r.errors, c), _.isValid && Z()), v.state.next({ ...r }));
+  }, hr = (c, l = {}) => {
+    const u = c ? ee(c) : n, w = ee(u), b = ne(c), g = b ? n : w;
+    if (l.keepDefaultValues || (n = u), !l.keepValues) {
+      if (l.keepDirtyValues) {
+        const A = /* @__PURE__ */ new Set([
+          ...o.mount,
+          ...Object.keys(ut(n, a))
+        ]);
+        for (const M of Array.from(A))
+          x(r.dirtyFields, M) ? D(g, M, x(a, M)) : K(M, x(g, M));
+      } else {
+        if (ar && Y(c))
+          for (const A of o.mount) {
+            const M = x(s, A);
+            if (M && M._f) {
+              const L = Array.isArray(M._f.refs) ? M._f.refs[0] : M._f.ref;
+              if (Pt(L)) {
+                const me = L.closest("form");
+                if (me) {
+                  me.reset();
+                  break;
+                }
+              }
+            }
+          }
+        for (const A of o.mount)
+          K(A, x(g, A));
+      }
+      a = ee(g), v.array.next({
+        values: { ...g }
+      }), v.state.next({
+        values: { ...g }
+      });
+    }
+    o = {
+      mount: l.keepDirtyValues ? o.mount : /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      disabled: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: !1,
+      focus: ""
+    }, i.mount = !_.isValid || !!l.keepIsValid || !!l.keepDirtyValues, i.watch = !!e.shouldUnregister, v.state.next({
+      submitCount: l.keepSubmitCount ? r.submitCount : 0,
+      isDirty: b ? !1 : l.keepDirty ? r.isDirty : !!(l.keepDefaultValues && !Ze(c, n)),
+      isSubmitted: l.keepIsSubmitted ? r.isSubmitted : !1,
+      dirtyFields: b ? {} : l.keepDirtyValues ? l.keepDefaultValues && a ? ut(n, a) : r.dirtyFields : l.keepDefaultValues && c ? ut(n, c) : l.keepDirty ? r.dirtyFields : {},
+      touchedFields: l.keepTouched ? r.touchedFields : {},
+      errors: l.keepErrors ? r.errors : {},
+      isSubmitSuccessful: l.keepIsSubmitSuccessful ? r.isSubmitSuccessful : !1,
+      isSubmitting: !1
+    });
+  }, mr = (c, l) => hr(ge(c) ? c(a) : c, l), ds = (c, l = {}) => {
+    const u = x(s, c), w = u && u._f;
+    if (w) {
+      const b = w.refs ? w.refs[0] : w.ref;
+      b.focus && (b.focus(), l.shouldSelect && ge(b.select) && b.select());
+    }
+  }, fs = (c) => {
+    r = {
+      ...r,
+      ...c
+    };
+  }, pr = {
+    control: {
+      register: we,
+      unregister: Be,
+      getFieldState: C,
+      handleSubmit: fr,
+      setError: H,
+      _subscribe: de,
+      _runSchema: xe,
+      _getWatch: V,
+      _getDirty: oe,
+      _setValid: Z,
+      _setFieldArray: pe,
+      _setDisabledField: G,
+      _setErrors: ce,
+      _getFieldArray: I,
+      _reset: hr,
+      _resetDefaultValues: () => ge(e.defaultValues) && e.defaultValues().then((c) => {
+        mr(c, e.resetOptions), v.state.next({
+          isLoading: !1
+        });
+      }),
+      _removeUnmounted: Ee,
+      _disableForm: Yt,
+      _subjects: v,
+      _proxyFormState: _,
+      get _fields() {
+        return s;
+      },
+      get _formValues() {
+        return a;
+      },
+      get _state() {
+        return i;
+      },
+      set _state(c) {
+        i = c;
+      },
+      get _defaultValues() {
+        return n;
+      },
+      get _names() {
+        return o;
+      },
+      set _names(c) {
+        o = c;
+      },
+      get _formState() {
+        return r;
+      },
+      get _options() {
+        return e;
+      },
+      set _options(c) {
+        e = {
+          ...e,
+          ...c
+        };
+      }
+    },
+    subscribe: ot,
+    trigger: Ne,
+    register: we,
+    handleSubmit: fr,
+    watch: ke,
+    setValue: K,
+    getValues: h,
+    reset: mr,
+    resetField: us,
+    clearErrors: U,
+    unregister: Be,
+    setError: H,
+    setFocus: ds,
+    getFieldState: C
+  };
+  return {
+    ...pr,
+    formControl: pr
+  };
+}
+function Qs(t = {}) {
+  const e = P.useRef(void 0), r = P.useRef(void 0), [s, n] = P.useState({
+    isDirty: !1,
+    isValidating: !1,
+    isLoading: ge(t.defaultValues),
+    isSubmitted: !1,
+    isSubmitting: !1,
+    isSubmitSuccessful: !1,
+    isValid: !1,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    validatingFields: {},
+    errors: t.errors || {},
+    disabled: t.disabled || !1,
+    isReady: !1,
+    defaultValues: ge(t.defaultValues) ? void 0 : t.defaultValues
+  });
+  e.current || (e.current = {
+    ...t.formControl ? t.formControl : Xs(t),
+    formState: s
+  }, t.formControl && t.defaultValues && !ge(t.defaultValues) && t.formControl.reset(t.defaultValues, t.resetOptions));
+  const a = e.current.control;
+  return a._options = t, cr(() => {
+    const i = a._subscribe({
+      formState: a._proxyFormState,
+      callback: () => n({ ...a._formState }),
+      reRenderRoot: !0
+    });
+    return n((o) => ({
+      ...o,
+      isReady: !0
+    })), a._formState.isReady = !0, i;
+  }, [a]), P.useEffect(() => a._disableForm(t.disabled), [a, t.disabled]), P.useEffect(() => {
+    t.mode && (a._options.mode = t.mode), t.reValidateMode && (a._options.reValidateMode = t.reValidateMode), t.errors && !ne(t.errors) && a._setErrors(t.errors);
+  }, [a, t.errors, t.mode, t.reValidateMode]), P.useEffect(() => {
+    t.shouldUnregister && a._subjects.state.next({
+      values: a._getWatch()
+    });
+  }, [a, t.shouldUnregister]), P.useEffect(() => {
+    if (a._proxyFormState.isDirty) {
+      const i = a._getDirty();
+      i !== s.isDirty && a._subjects.state.next({
+        isDirty: i
+      });
+    }
+  }, [a, s.isDirty]), P.useEffect(() => {
+    t.values && !Ze(t.values, r.current) ? (a._reset(t.values, a._options.resetOptions), r.current = t.values, n((i) => ({ ...i }))) : a._resetDefaultValues();
+  }, [a, t.values]), P.useEffect(() => {
+    a._state.mount || (a._setValid(), a._state.mount = !0), a._state.watch && (a._state.watch = !1, a._subjects.state.next({ ...a._formState })), a._removeUnmounted();
+  }), e.current.formState = Wr(s, a), e.current;
+}
+const Pr = (t, e, r) => {
+  if (t && "reportValidity" in t) {
+    const s = x(r, e);
+    t.setCustomValidity(s && s.message || ""), t.reportValidity();
+  }
+}, es = (t, e) => {
+  for (const r in e.fields) {
+    const s = e.fields[r];
+    s && s.ref && "reportValidity" in s.ref ? Pr(s.ref, r, t) : s && s.refs && s.refs.forEach((n) => Pr(n, r, t));
+  }
+}, Ks = (t, e) => {
+  e.shouldUseNativeValidation && es(t, e);
+  const r = {};
+  for (const s in t) {
+    const n = x(e.fields, s), a = Object.assign(t[s] || {}, { ref: n && n.ref });
+    if (en(e.names || Object.keys(t), s)) {
+      const i = Object.assign({}, x(r, s));
+      D(i, "root", a), D(r, s, i);
+    } else D(r, s, a);
+  }
+  return r;
+}, en = (t, e) => {
+  const r = Ir(e);
+  return t.some((s) => Ir(s).match(`^${r}\\.\\d+`));
+};
+function Ir(t) {
+  return t.replace(/\]|\[/g, "");
+}
+function tn(t, e) {
+  for (var r = {}; t.length; ) {
+    var s = t[0], n = s.code, a = s.message, i = s.path.join(".");
+    if (!r[i]) if ("unionErrors" in s) {
+      var o = s.unionErrors[0].errors[0];
+      r[i] = { message: o.message, type: o.code };
+    } else r[i] = { message: a, type: n };
+    if ("unionErrors" in s && s.unionErrors.forEach(function(_) {
+      return _.errors.forEach(function(y) {
+        return t.push(y);
+      });
+    }), e) {
+      var d = r[i].types, f = d && d[s.code];
+      r[i] = Yr(i, e, r, n, f ? [].concat(f, s.message) : s.message);
+    }
+    t.shift();
+  }
+  return r;
+}
+function rn(t, e, r) {
+  return r === void 0 && (r = {}), function(s, n, a) {
+    try {
+      return Promise.resolve(function(i, o) {
+        try {
+          var d = Promise.resolve(t[r.mode === "sync" ? "parse" : "parseAsync"](s, e)).then(function(f) {
+            return a.shouldUseNativeValidation && es({}, a), { errors: {}, values: r.raw ? Object.assign({}, s) : f };
+          });
+        } catch (f) {
+          return o(f);
+        }
+        return d && d.then ? d.then(void 0, o) : d;
+      }(0, function(i) {
+        if (function(o) {
+          return Array.isArray(o == null ? void 0 : o.errors);
+        }(i)) return { values: {}, errors: Ks(tn(i.errors, !a.shouldUseNativeValidation && a.criteriaMode === "all"), a) };
+        throw i;
+      }));
+    } catch (i) {
+      return Promise.reject(i);
+    }
+  };
+}
+var F;
+(function(t) {
+  t.assertEqual = (n) => {
+  };
+  function e(n) {
+  }
+  t.assertIs = e;
+  function r(n) {
+    throw new Error();
+  }
+  t.assertNever = r, t.arrayToEnum = (n) => {
+    const a = {};
+    for (const i of n)
+      a[i] = i;
+    return a;
+  }, t.getValidEnumValues = (n) => {
+    const a = t.objectKeys(n).filter((o) => typeof n[n[o]] != "number"), i = {};
+    for (const o of a)
+      i[o] = n[o];
+    return t.objectValues(i);
+  }, t.objectValues = (n) => t.objectKeys(n).map(function(a) {
+    return n[a];
+  }), t.objectKeys = typeof Object.keys == "function" ? (n) => Object.keys(n) : (n) => {
+    const a = [];
+    for (const i in n)
+      Object.prototype.hasOwnProperty.call(n, i) && a.push(i);
+    return a;
+  }, t.find = (n, a) => {
+    for (const i of n)
+      if (a(i))
+        return i;
+  }, t.isInteger = typeof Number.isInteger == "function" ? (n) => Number.isInteger(n) : (n) => typeof n == "number" && Number.isFinite(n) && Math.floor(n) === n;
+  function s(n, a = " | ") {
+    return n.map((i) => typeof i == "string" ? `'${i}'` : i).join(a);
+  }
+  t.joinValues = s, t.jsonStringifyReplacer = (n, a) => typeof a == "bigint" ? a.toString() : a;
+})(F || (F = {}));
+var er;
+(function(t) {
+  t.mergeShapes = (e, r) => ({
+    ...e,
+    ...r
+    // second overwrites first
+  });
+})(er || (er = {}));
+const T = F.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]), Ve = (t) => {
+  switch (typeof t) {
+    case "undefined":
+      return T.undefined;
+    case "string":
+      return T.string;
+    case "number":
+      return Number.isNaN(t) ? T.nan : T.number;
+    case "boolean":
+      return T.boolean;
+    case "function":
+      return T.function;
+    case "bigint":
+      return T.bigint;
+    case "symbol":
+      return T.symbol;
+    case "object":
+      return Array.isArray(t) ? T.array : t === null ? T.null : t.then && typeof t.then == "function" && t.catch && typeof t.catch == "function" ? T.promise : typeof Map < "u" && t instanceof Map ? T.map : typeof Set < "u" && t instanceof Set ? T.set : typeof Date < "u" && t instanceof Date ? T.date : T.object;
+    default:
+      return T.unknown;
+  }
+}, m = F.arrayToEnum([
+  "invalid_type",
+  "invalid_literal",
+  "custom",
+  "invalid_union",
+  "invalid_union_discriminator",
+  "invalid_enum_value",
+  "unrecognized_keys",
+  "invalid_arguments",
+  "invalid_return_type",
+  "invalid_date",
+  "invalid_string",
+  "too_small",
+  "too_big",
+  "invalid_intersection_types",
+  "not_multiple_of",
+  "not_finite"
+]), sn = (t) => JSON.stringify(t, null, 2).replace(/"([^"]+)":/g, "$1:");
+class he extends Error {
+  get errors() {
+    return this.issues;
+  }
+  constructor(e) {
+    super(), this.issues = [], this.addIssue = (s) => {
+      this.issues = [...this.issues, s];
+    }, this.addIssues = (s = []) => {
+      this.issues = [...this.issues, ...s];
+    };
+    const r = new.target.prototype;
+    Object.setPrototypeOf ? Object.setPrototypeOf(this, r) : this.__proto__ = r, this.name = "ZodError", this.issues = e;
+  }
+  format(e) {
+    const r = e || function(a) {
+      return a.message;
+    }, s = { _errors: [] }, n = (a) => {
+      for (const i of a.issues)
+        if (i.code === "invalid_union")
+          i.unionErrors.map(n);
+        else if (i.code === "invalid_return_type")
+          n(i.returnTypeError);
+        else if (i.code === "invalid_arguments")
+          n(i.argumentsError);
+        else if (i.path.length === 0)
+          s._errors.push(r(i));
+        else {
+          let o = s, d = 0;
+          for (; d < i.path.length; ) {
+            const f = i.path[d];
+            d === i.path.length - 1 ? (o[f] = o[f] || { _errors: [] }, o[f]._errors.push(r(i))) : o[f] = o[f] || { _errors: [] }, o = o[f], d++;
+          }
+        }
+    };
+    return n(this), s;
+  }
+  static assert(e) {
+    if (!(e instanceof he))
+      throw new Error(`Not a ZodError: ${e}`);
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, F.jsonStringifyReplacer, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(e = (r) => r.message) {
+    const r = {}, s = [];
+    for (const n of this.issues)
+      n.path.length > 0 ? (r[n.path[0]] = r[n.path[0]] || [], r[n.path[0]].push(e(n))) : s.push(e(n));
+    return { formErrors: s, fieldErrors: r };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+}
+he.create = (t) => new he(t);
+const nt = (t, e) => {
+  let r;
+  switch (t.code) {
+    case m.invalid_type:
+      t.received === T.undefined ? r = "Required" : r = `Expected ${t.expected}, received ${t.received}`;
+      break;
+    case m.invalid_literal:
+      r = `Invalid literal value, expected ${JSON.stringify(t.expected, F.jsonStringifyReplacer)}`;
+      break;
+    case m.unrecognized_keys:
+      r = `Unrecognized key(s) in object: ${F.joinValues(t.keys, ", ")}`;
+      break;
+    case m.invalid_union:
+      r = "Invalid input";
+      break;
+    case m.invalid_union_discriminator:
+      r = `Invalid discriminator value. Expected ${F.joinValues(t.options)}`;
+      break;
+    case m.invalid_enum_value:
+      r = `Invalid enum value. Expected ${F.joinValues(t.options)}, received '${t.received}'`;
+      break;
+    case m.invalid_arguments:
+      r = "Invalid function arguments";
+      break;
+    case m.invalid_return_type:
+      r = "Invalid function return type";
+      break;
+    case m.invalid_date:
+      r = "Invalid date";
+      break;
+    case m.invalid_string:
+      typeof t.validation == "object" ? "includes" in t.validation ? (r = `Invalid input: must include "${t.validation.includes}"`, typeof t.validation.position == "number" && (r = `${r} at one or more positions greater than or equal to ${t.validation.position}`)) : "startsWith" in t.validation ? r = `Invalid input: must start with "${t.validation.startsWith}"` : "endsWith" in t.validation ? r = `Invalid input: must end with "${t.validation.endsWith}"` : F.assertNever(t.validation) : t.validation !== "regex" ? r = `Invalid ${t.validation}` : r = "Invalid";
+      break;
+    case m.too_small:
+      t.type === "array" ? r = `Array must contain ${t.exact ? "exactly" : t.inclusive ? "at least" : "more than"} ${t.minimum} element(s)` : t.type === "string" ? r = `String must contain ${t.exact ? "exactly" : t.inclusive ? "at least" : "over"} ${t.minimum} character(s)` : t.type === "number" ? r = `Number must be ${t.exact ? "exactly equal to " : t.inclusive ? "greater than or equal to " : "greater than "}${t.minimum}` : t.type === "date" ? r = `Date must be ${t.exact ? "exactly equal to " : t.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(t.minimum))}` : r = "Invalid input";
+      break;
+    case m.too_big:
+      t.type === "array" ? r = `Array must contain ${t.exact ? "exactly" : t.inclusive ? "at most" : "less than"} ${t.maximum} element(s)` : t.type === "string" ? r = `String must contain ${t.exact ? "exactly" : t.inclusive ? "at most" : "under"} ${t.maximum} character(s)` : t.type === "number" ? r = `Number must be ${t.exact ? "exactly" : t.inclusive ? "less than or equal to" : "less than"} ${t.maximum}` : t.type === "bigint" ? r = `BigInt must be ${t.exact ? "exactly" : t.inclusive ? "less than or equal to" : "less than"} ${t.maximum}` : t.type === "date" ? r = `Date must be ${t.exact ? "exactly" : t.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(t.maximum))}` : r = "Invalid input";
+      break;
+    case m.custom:
+      r = "Invalid input";
+      break;
+    case m.invalid_intersection_types:
+      r = "Intersection results could not be merged";
+      break;
+    case m.not_multiple_of:
+      r = `Number must be a multiple of ${t.multipleOf}`;
+      break;
+    case m.not_finite:
+      r = "Number must be finite";
+      break;
+    default:
+      r = e.defaultError, F.assertNever(t);
+  }
+  return { message: r };
+};
+let ts = nt;
+function nn(t) {
+  ts = t;
+}
+function Mt() {
+  return ts;
+}
+const Zt = (t) => {
+  const { data: e, path: r, errorMaps: s, issueData: n } = t, a = [...r, ...n.path || []], i = {
+    ...n,
+    path: a
+  };
+  if (n.message !== void 0)
+    return {
+      ...n,
+      path: a,
+      message: n.message
+    };
+  let o = "";
+  const d = s.filter((f) => !!f).slice().reverse();
+  for (const f of d)
+    o = f(i, { data: e, defaultError: o }).message;
+  return {
+    ...n,
+    path: a,
+    message: o
+  };
+}, an = [];
+function k(t, e) {
+  const r = Mt(), s = Zt({
+    issueData: e,
+    data: t.data,
+    path: t.path,
+    errorMaps: [
+      t.common.contextualErrorMap,
+      // contextual error map is first priority
+      t.schemaErrorMap,
+      // then schema-bound map if available
+      r,
+      // then global override map
+      r === nt ? void 0 : nt
+      // then global default map
+    ].filter((n) => !!n)
+  });
+  t.common.issues.push(s);
+}
+class se {
+  constructor() {
+    this.value = "valid";
+  }
+  dirty() {
+    this.value === "valid" && (this.value = "dirty");
+  }
+  abort() {
+    this.value !== "aborted" && (this.value = "aborted");
+  }
+  static mergeArray(e, r) {
+    const s = [];
+    for (const n of r) {
+      if (n.status === "aborted")
+        return j;
+      n.status === "dirty" && e.dirty(), s.push(n.value);
+    }
+    return { status: e.value, value: s };
+  }
+  static async mergeObjectAsync(e, r) {
+    const s = [];
+    for (const n of r) {
+      const a = await n.key, i = await n.value;
+      s.push({
+        key: a,
+        value: i
+      });
+    }
+    return se.mergeObjectSync(e, s);
+  }
+  static mergeObjectSync(e, r) {
+    const s = {};
+    for (const n of r) {
+      const { key: a, value: i } = n;
+      if (a.status === "aborted" || i.status === "aborted")
+        return j;
+      a.status === "dirty" && e.dirty(), i.status === "dirty" && e.dirty(), a.value !== "__proto__" && (typeof i.value < "u" || n.alwaysSet) && (s[a.value] = i.value);
+    }
+    return { status: e.value, value: s };
+  }
+}
+const j = Object.freeze({
+  status: "aborted"
+}), rt = (t) => ({ status: "dirty", value: t }), ie = (t) => ({ status: "valid", value: t }), tr = (t) => t.status === "aborted", rr = (t) => t.status === "dirty", Je = (t) => t.status === "valid", pt = (t) => typeof Promise < "u" && t instanceof Promise;
+var S;
+(function(t) {
+  t.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, t.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message;
+})(S || (S = {}));
+class Ae {
+  constructor(e, r, s, n) {
+    this._cachedPath = [], this.parent = e, this.data = r, this._path = s, this._key = n;
+  }
+  get path() {
+    return this._cachedPath.length || (Array.isArray(this._key) ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath;
+  }
+}
+const Dr = (t, e) => {
+  if (Je(e))
+    return { success: !0, data: e.value };
+  if (!t.common.issues.length)
+    throw new Error("Validation failed but no issues detected.");
+  return {
+    success: !1,
+    get error() {
+      if (this._error)
+        return this._error;
+      const r = new he(t.common.issues);
+      return this._error = r, this._error;
+    }
+  };
+};
+function N(t) {
+  if (!t)
+    return {};
+  const { errorMap: e, invalid_type_error: r, required_error: s, description: n } = t;
+  if (e && (r || s))
+    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+  return e ? { errorMap: e, description: n } : { errorMap: (i, o) => {
+    const { message: d } = t;
+    return i.code === "invalid_enum_value" ? { message: d ?? o.defaultError } : typeof o.data > "u" ? { message: d ?? s ?? o.defaultError } : i.code !== "invalid_type" ? { message: o.defaultError } : { message: d ?? r ?? o.defaultError };
+  }, description: n };
+}
+class O {
+  get description() {
+    return this._def.description;
+  }
+  _getType(e) {
+    return Ve(e.data);
+  }
+  _getOrReturnCtx(e, r) {
+    return r || {
+      common: e.parent.common,
+      data: e.data,
+      parsedType: Ve(e.data),
+      schemaErrorMap: this._def.errorMap,
+      path: e.path,
+      parent: e.parent
+    };
+  }
+  _processInputParams(e) {
+    return {
+      status: new se(),
+      ctx: {
+        common: e.parent.common,
+        data: e.data,
+        parsedType: Ve(e.data),
+        schemaErrorMap: this._def.errorMap,
+        path: e.path,
+        parent: e.parent
+      }
+    };
+  }
+  _parseSync(e) {
+    const r = this._parse(e);
+    if (pt(r))
+      throw new Error("Synchronous parse encountered promise.");
+    return r;
+  }
+  _parseAsync(e) {
+    const r = this._parse(e);
+    return Promise.resolve(r);
+  }
+  parse(e, r) {
+    const s = this.safeParse(e, r);
+    if (s.success)
+      return s.data;
+    throw s.error;
+  }
+  safeParse(e, r) {
+    const s = {
+      common: {
+        issues: [],
+        async: (r == null ? void 0 : r.async) ?? !1,
+        contextualErrorMap: r == null ? void 0 : r.errorMap
+      },
+      path: (r == null ? void 0 : r.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: Ve(e)
+    }, n = this._parseSync({ data: e, path: s.path, parent: s });
+    return Dr(s, n);
+  }
+  "~validate"(e) {
+    var s, n;
+    const r = {
+      common: {
+        issues: [],
+        async: !!this["~standard"].async
+      },
+      path: [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: Ve(e)
+    };
+    if (!this["~standard"].async)
+      try {
+        const a = this._parseSync({ data: e, path: [], parent: r });
+        return Je(a) ? {
+          value: a.value
+        } : {
+          issues: r.common.issues
+        };
+      } catch (a) {
+        (n = (s = a == null ? void 0 : a.message) == null ? void 0 : s.toLowerCase()) != null && n.includes("encountered") && (this["~standard"].async = !0), r.common = {
+          issues: [],
+          async: !0
+        };
+      }
+    return this._parseAsync({ data: e, path: [], parent: r }).then((a) => Je(a) ? {
+      value: a.value
+    } : {
+      issues: r.common.issues
+    });
+  }
+  async parseAsync(e, r) {
+    const s = await this.safeParseAsync(e, r);
+    if (s.success)
+      return s.data;
+    throw s.error;
+  }
+  async safeParseAsync(e, r) {
+    const s = {
+      common: {
+        issues: [],
+        contextualErrorMap: r == null ? void 0 : r.errorMap,
+        async: !0
+      },
+      path: (r == null ? void 0 : r.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: Ve(e)
+    }, n = this._parse({ data: e, path: s.path, parent: s }), a = await (pt(n) ? n : Promise.resolve(n));
+    return Dr(s, a);
+  }
+  refine(e, r) {
+    const s = (n) => typeof r == "string" || typeof r > "u" ? { message: r } : typeof r == "function" ? r(n) : r;
+    return this._refinement((n, a) => {
+      const i = e(n), o = () => a.addIssue({
+        code: m.custom,
+        ...s(n)
+      });
+      return typeof Promise < "u" && i instanceof Promise ? i.then((d) => d ? !0 : (o(), !1)) : i ? !0 : (o(), !1);
+    });
+  }
+  refinement(e, r) {
+    return this._refinement((s, n) => e(s) ? !0 : (n.addIssue(typeof r == "function" ? r(s, n) : r), !1));
+  }
+  _refinement(e) {
+    return new be({
+      schema: this,
+      typeName: E.ZodEffects,
+      effect: { type: "refinement", refinement: e }
+    });
+  }
+  superRefine(e) {
+    return this._refinement(e);
+  }
+  constructor(e) {
+    this.spa = this.safeParseAsync, this._def = e, this.parse = this.parse.bind(this), this.safeParse = this.safeParse.bind(this), this.parseAsync = this.parseAsync.bind(this), this.safeParseAsync = this.safeParseAsync.bind(this), this.spa = this.spa.bind(this), this.refine = this.refine.bind(this), this.refinement = this.refinement.bind(this), this.superRefine = this.superRefine.bind(this), this.optional = this.optional.bind(this), this.nullable = this.nullable.bind(this), this.nullish = this.nullish.bind(this), this.array = this.array.bind(this), this.promise = this.promise.bind(this), this.or = this.or.bind(this), this.and = this.and.bind(this), this.transform = this.transform.bind(this), this.brand = this.brand.bind(this), this.default = this.default.bind(this), this.catch = this.catch.bind(this), this.describe = this.describe.bind(this), this.pipe = this.pipe.bind(this), this.readonly = this.readonly.bind(this), this.isNullable = this.isNullable.bind(this), this.isOptional = this.isOptional.bind(this), this["~standard"] = {
+      version: 1,
+      vendor: "zod",
+      validate: (r) => this["~validate"](r)
+    };
+  }
+  optional() {
+    return Se.create(this, this._def);
+  }
+  nullable() {
+    return ze.create(this, this._def);
+  }
+  nullish() {
+    return this.nullable().optional();
+  }
+  array() {
+    return _e.create(this);
+  }
+  promise() {
+    return it.create(this, this._def);
+  }
+  or(e) {
+    return _t.create([this, e], this._def);
+  }
+  and(e) {
+    return bt.create(this, e, this._def);
+  }
+  transform(e) {
+    return new be({
+      ...N(this._def),
+      schema: this,
+      typeName: E.ZodEffects,
+      effect: { type: "transform", transform: e }
+    });
+  }
+  default(e) {
+    const r = typeof e == "function" ? e : () => e;
+    return new St({
+      ...N(this._def),
+      innerType: this,
+      defaultValue: r,
+      typeName: E.ZodDefault
+    });
+  }
+  brand() {
+    return new dr({
+      typeName: E.ZodBranded,
+      type: this,
+      ...N(this._def)
+    });
+  }
+  catch(e) {
+    const r = typeof e == "function" ? e : () => e;
+    return new At({
+      ...N(this._def),
+      innerType: this,
+      catchValue: r,
+      typeName: E.ZodCatch
+    });
+  }
+  describe(e) {
+    const r = this.constructor;
+    return new r({
+      ...this._def,
+      description: e
+    });
+  }
+  pipe(e) {
+    return Ct.create(this, e);
+  }
+  readonly() {
+    return jt.create(this);
+  }
+  isOptional() {
+    return this.safeParse(void 0).success;
+  }
+  isNullable() {
+    return this.safeParse(null).success;
+  }
+}
+const on = /^c[^\s-]{8,}$/i, cn = /^[0-9a-z]+$/, ln = /^[0-9A-HJKMNP-TV-Z]{26}$/i, un = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i, dn = /^[a-z0-9_-]{21}$/i, fn = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/, hn = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/, mn = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, pn = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+let Xt;
+const yn = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, gn = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/, vn = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/, _n = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, bn = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, xn = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, rs = "((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))", kn = new RegExp(`^${rs}$`);
+function ss(t) {
+  let e = "[0-5]\\d";
+  t.precision ? e = `${e}\\.\\d{${t.precision}}` : t.precision == null && (e = `${e}(\\.\\d+)?`);
+  const r = t.precision ? "+" : "?";
+  return `([01]\\d|2[0-3]):[0-5]\\d(:${e})${r}`;
+}
+function wn(t) {
+  return new RegExp(`^${ss(t)}$`);
+}
+function ns(t) {
+  let e = `${rs}T${ss(t)}`;
+  const r = [];
+  return r.push(t.local ? "Z?" : "Z"), t.offset && r.push("([+-]\\d{2}:?\\d{2})"), e = `${e}(${r.join("|")})`, new RegExp(`^${e}$`);
+}
+function Tn(t, e) {
+  return !!((e === "v4" || !e) && yn.test(t) || (e === "v6" || !e) && vn.test(t));
+}
+function Sn(t, e) {
+  if (!fn.test(t))
+    return !1;
+  try {
+    const [r] = t.split("."), s = r.replace(/-/g, "+").replace(/_/g, "/").padEnd(r.length + (4 - r.length % 4) % 4, "="), n = JSON.parse(atob(s));
+    return !(typeof n != "object" || n === null || "typ" in n && (n == null ? void 0 : n.typ) !== "JWT" || !n.alg || e && n.alg !== e);
+  } catch {
+    return !1;
+  }
+}
+function An(t, e) {
+  return !!((e === "v4" || !e) && gn.test(t) || (e === "v6" || !e) && _n.test(t));
+}
+class ve extends O {
+  _parse(e) {
+    if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== T.string) {
+      const a = this._getOrReturnCtx(e);
+      return k(a, {
+        code: m.invalid_type,
+        expected: T.string,
+        received: a.parsedType
+      }), j;
+    }
+    const s = new se();
+    let n;
+    for (const a of this._def.checks)
+      if (a.kind === "min")
+        e.data.length < a.value && (n = this._getOrReturnCtx(e, n), k(n, {
+          code: m.too_small,
+          minimum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: a.message
+        }), s.dirty());
+      else if (a.kind === "max")
+        e.data.length > a.value && (n = this._getOrReturnCtx(e, n), k(n, {
+          code: m.too_big,
+          maximum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: a.message
+        }), s.dirty());
+      else if (a.kind === "length") {
+        const i = e.data.length > a.value, o = e.data.length < a.value;
+        (i || o) && (n = this._getOrReturnCtx(e, n), i ? k(n, {
+          code: m.too_big,
+          maximum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: a.message
+        }) : o && k(n, {
+          code: m.too_small,
+          minimum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: a.message
+        }), s.dirty());
+      } else if (a.kind === "email")
+        mn.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+          validation: "email",
+          code: m.invalid_string,
+          message: a.message
+        }), s.dirty());
+      else if (a.kind === "emoji")
+        Xt || (Xt = new RegExp(pn, "u")), Xt.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+          validation: "emoji",
+          code: m.invalid_string,
+          message: a.message
+        }), s.dirty());
+      else if (a.kind === "uuid")
+        un.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+          validation: "uuid",
+          code: m.invalid_string,
+          message: a.message
+        }), s.dirty());
+      else if (a.kind === "nanoid")
+        dn.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+          validation: "nanoid",
+          code: m.invalid_string,
+          message: a.message
+        }), s.dirty());
+      else if (a.kind === "cuid")
+        on.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+          validation: "cuid",
+          code: m.invalid_string,
+          message: a.message
+        }), s.dirty());
+      else if (a.kind === "cuid2")
+        cn.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+          validation: "cuid2",
+          code: m.invalid_string,
+          message: a.message
+        }), s.dirty());
+      else if (a.kind === "ulid")
+        ln.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+          validation: "ulid",
+          code: m.invalid_string,
+          message: a.message
+        }), s.dirty());
+      else if (a.kind === "url")
+        try {
+          new URL(e.data);
+        } catch {
+          n = this._getOrReturnCtx(e, n), k(n, {
+            validation: "url",
+            code: m.invalid_string,
+            message: a.message
+          }), s.dirty();
+        }
+      else a.kind === "regex" ? (a.regex.lastIndex = 0, a.regex.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+        validation: "regex",
+        code: m.invalid_string,
+        message: a.message
+      }), s.dirty())) : a.kind === "trim" ? e.data = e.data.trim() : a.kind === "includes" ? e.data.includes(a.value, a.position) || (n = this._getOrReturnCtx(e, n), k(n, {
+        code: m.invalid_string,
+        validation: { includes: a.value, position: a.position },
+        message: a.message
+      }), s.dirty()) : a.kind === "toLowerCase" ? e.data = e.data.toLowerCase() : a.kind === "toUpperCase" ? e.data = e.data.toUpperCase() : a.kind === "startsWith" ? e.data.startsWith(a.value) || (n = this._getOrReturnCtx(e, n), k(n, {
+        code: m.invalid_string,
+        validation: { startsWith: a.value },
+        message: a.message
+      }), s.dirty()) : a.kind === "endsWith" ? e.data.endsWith(a.value) || (n = this._getOrReturnCtx(e, n), k(n, {
+        code: m.invalid_string,
+        validation: { endsWith: a.value },
+        message: a.message
+      }), s.dirty()) : a.kind === "datetime" ? ns(a).test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+        code: m.invalid_string,
+        validation: "datetime",
+        message: a.message
+      }), s.dirty()) : a.kind === "date" ? kn.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+        code: m.invalid_string,
+        validation: "date",
+        message: a.message
+      }), s.dirty()) : a.kind === "time" ? wn(a).test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+        code: m.invalid_string,
+        validation: "time",
+        message: a.message
+      }), s.dirty()) : a.kind === "duration" ? hn.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+        validation: "duration",
+        code: m.invalid_string,
+        message: a.message
+      }), s.dirty()) : a.kind === "ip" ? Tn(e.data, a.version) || (n = this._getOrReturnCtx(e, n), k(n, {
+        validation: "ip",
+        code: m.invalid_string,
+        message: a.message
+      }), s.dirty()) : a.kind === "jwt" ? Sn(e.data, a.alg) || (n = this._getOrReturnCtx(e, n), k(n, {
+        validation: "jwt",
+        code: m.invalid_string,
+        message: a.message
+      }), s.dirty()) : a.kind === "cidr" ? An(e.data, a.version) || (n = this._getOrReturnCtx(e, n), k(n, {
+        validation: "cidr",
+        code: m.invalid_string,
+        message: a.message
+      }), s.dirty()) : a.kind === "base64" ? bn.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+        validation: "base64",
+        code: m.invalid_string,
+        message: a.message
+      }), s.dirty()) : a.kind === "base64url" ? xn.test(e.data) || (n = this._getOrReturnCtx(e, n), k(n, {
+        validation: "base64url",
+        code: m.invalid_string,
+        message: a.message
+      }), s.dirty()) : F.assertNever(a);
+    return { status: s.value, value: e.data };
+  }
+  _regex(e, r, s) {
+    return this.refinement((n) => e.test(n), {
+      validation: r,
+      code: m.invalid_string,
+      ...S.errToObj(s)
+    });
+  }
+  _addCheck(e) {
+    return new ve({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  email(e) {
+    return this._addCheck({ kind: "email", ...S.errToObj(e) });
+  }
+  url(e) {
+    return this._addCheck({ kind: "url", ...S.errToObj(e) });
+  }
+  emoji(e) {
+    return this._addCheck({ kind: "emoji", ...S.errToObj(e) });
+  }
+  uuid(e) {
+    return this._addCheck({ kind: "uuid", ...S.errToObj(e) });
+  }
+  nanoid(e) {
+    return this._addCheck({ kind: "nanoid", ...S.errToObj(e) });
+  }
+  cuid(e) {
+    return this._addCheck({ kind: "cuid", ...S.errToObj(e) });
+  }
+  cuid2(e) {
+    return this._addCheck({ kind: "cuid2", ...S.errToObj(e) });
+  }
+  ulid(e) {
+    return this._addCheck({ kind: "ulid", ...S.errToObj(e) });
+  }
+  base64(e) {
+    return this._addCheck({ kind: "base64", ...S.errToObj(e) });
+  }
+  base64url(e) {
+    return this._addCheck({
+      kind: "base64url",
+      ...S.errToObj(e)
+    });
+  }
+  jwt(e) {
+    return this._addCheck({ kind: "jwt", ...S.errToObj(e) });
+  }
+  ip(e) {
+    return this._addCheck({ kind: "ip", ...S.errToObj(e) });
+  }
+  cidr(e) {
+    return this._addCheck({ kind: "cidr", ...S.errToObj(e) });
+  }
+  datetime(e) {
+    return typeof e == "string" ? this._addCheck({
+      kind: "datetime",
+      precision: null,
+      offset: !1,
+      local: !1,
+      message: e
+    }) : this._addCheck({
+      kind: "datetime",
+      precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision,
+      offset: (e == null ? void 0 : e.offset) ?? !1,
+      local: (e == null ? void 0 : e.local) ?? !1,
+      ...S.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  date(e) {
+    return this._addCheck({ kind: "date", message: e });
+  }
+  time(e) {
+    return typeof e == "string" ? this._addCheck({
+      kind: "time",
+      precision: null,
+      message: e
+    }) : this._addCheck({
+      kind: "time",
+      precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision,
+      ...S.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  duration(e) {
+    return this._addCheck({ kind: "duration", ...S.errToObj(e) });
+  }
+  regex(e, r) {
+    return this._addCheck({
+      kind: "regex",
+      regex: e,
+      ...S.errToObj(r)
+    });
+  }
+  includes(e, r) {
+    return this._addCheck({
+      kind: "includes",
+      value: e,
+      position: r == null ? void 0 : r.position,
+      ...S.errToObj(r == null ? void 0 : r.message)
+    });
+  }
+  startsWith(e, r) {
+    return this._addCheck({
+      kind: "startsWith",
+      value: e,
+      ...S.errToObj(r)
+    });
+  }
+  endsWith(e, r) {
+    return this._addCheck({
+      kind: "endsWith",
+      value: e,
+      ...S.errToObj(r)
+    });
+  }
+  min(e, r) {
+    return this._addCheck({
+      kind: "min",
+      value: e,
+      ...S.errToObj(r)
+    });
+  }
+  max(e, r) {
+    return this._addCheck({
+      kind: "max",
+      value: e,
+      ...S.errToObj(r)
+    });
+  }
+  length(e, r) {
+    return this._addCheck({
+      kind: "length",
+      value: e,
+      ...S.errToObj(r)
+    });
+  }
+  /**
+   * Equivalent to `.min(1)`
+   */
+  nonempty(e) {
+    return this.min(1, S.errToObj(e));
+  }
+  trim() {
+    return new ve({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "trim" }]
+    });
+  }
+  toLowerCase() {
+    return new ve({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toLowerCase" }]
+    });
+  }
+  toUpperCase() {
+    return new ve({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toUpperCase" }]
+    });
+  }
+  get isDatetime() {
+    return !!this._def.checks.find((e) => e.kind === "datetime");
+  }
+  get isDate() {
+    return !!this._def.checks.find((e) => e.kind === "date");
+  }
+  get isTime() {
+    return !!this._def.checks.find((e) => e.kind === "time");
+  }
+  get isDuration() {
+    return !!this._def.checks.find((e) => e.kind === "duration");
+  }
+  get isEmail() {
+    return !!this._def.checks.find((e) => e.kind === "email");
+  }
+  get isURL() {
+    return !!this._def.checks.find((e) => e.kind === "url");
+  }
+  get isEmoji() {
+    return !!this._def.checks.find((e) => e.kind === "emoji");
+  }
+  get isUUID() {
+    return !!this._def.checks.find((e) => e.kind === "uuid");
+  }
+  get isNANOID() {
+    return !!this._def.checks.find((e) => e.kind === "nanoid");
+  }
+  get isCUID() {
+    return !!this._def.checks.find((e) => e.kind === "cuid");
+  }
+  get isCUID2() {
+    return !!this._def.checks.find((e) => e.kind === "cuid2");
+  }
+  get isULID() {
+    return !!this._def.checks.find((e) => e.kind === "ulid");
+  }
+  get isIP() {
+    return !!this._def.checks.find((e) => e.kind === "ip");
+  }
+  get isCIDR() {
+    return !!this._def.checks.find((e) => e.kind === "cidr");
+  }
+  get isBase64() {
+    return !!this._def.checks.find((e) => e.kind === "base64");
+  }
+  get isBase64url() {
+    return !!this._def.checks.find((e) => e.kind === "base64url");
+  }
+  get minLength() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "min" && (e === null || r.value > e) && (e = r.value);
+    return e;
+  }
+  get maxLength() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+    return e;
+  }
+}
+ve.create = (t) => new ve({
+  checks: [],
+  typeName: E.ZodString,
+  coerce: (t == null ? void 0 : t.coerce) ?? !1,
+  ...N(t)
+});
+function jn(t, e) {
+  const r = (t.toString().split(".")[1] || "").length, s = (e.toString().split(".")[1] || "").length, n = r > s ? r : s, a = Number.parseInt(t.toFixed(n).replace(".", "")), i = Number.parseInt(e.toFixed(n).replace(".", ""));
+  return a % i / 10 ** n;
+}
+class Le extends O {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte, this.step = this.multipleOf;
+  }
+  _parse(e) {
+    if (this._def.coerce && (e.data = Number(e.data)), this._getType(e) !== T.number) {
+      const a = this._getOrReturnCtx(e);
+      return k(a, {
+        code: m.invalid_type,
+        expected: T.number,
+        received: a.parsedType
+      }), j;
+    }
+    let s;
+    const n = new se();
+    for (const a of this._def.checks)
+      a.kind === "int" ? F.isInteger(e.data) || (s = this._getOrReturnCtx(e, s), k(s, {
+        code: m.invalid_type,
+        expected: "integer",
+        received: "float",
+        message: a.message
+      }), n.dirty()) : a.kind === "min" ? (a.inclusive ? e.data < a.value : e.data <= a.value) && (s = this._getOrReturnCtx(e, s), k(s, {
+        code: m.too_small,
+        minimum: a.value,
+        type: "number",
+        inclusive: a.inclusive,
+        exact: !1,
+        message: a.message
+      }), n.dirty()) : a.kind === "max" ? (a.inclusive ? e.data > a.value : e.data >= a.value) && (s = this._getOrReturnCtx(e, s), k(s, {
+        code: m.too_big,
+        maximum: a.value,
+        type: "number",
+        inclusive: a.inclusive,
+        exact: !1,
+        message: a.message
+      }), n.dirty()) : a.kind === "multipleOf" ? jn(e.data, a.value) !== 0 && (s = this._getOrReturnCtx(e, s), k(s, {
+        code: m.not_multiple_of,
+        multipleOf: a.value,
+        message: a.message
+      }), n.dirty()) : a.kind === "finite" ? Number.isFinite(e.data) || (s = this._getOrReturnCtx(e, s), k(s, {
+        code: m.not_finite,
+        message: a.message
+      }), n.dirty()) : F.assertNever(a);
+    return { status: n.value, value: e.data };
+  }
+  gte(e, r) {
+    return this.setLimit("min", e, !0, S.toString(r));
+  }
+  gt(e, r) {
+    return this.setLimit("min", e, !1, S.toString(r));
+  }
+  lte(e, r) {
+    return this.setLimit("max", e, !0, S.toString(r));
+  }
+  lt(e, r) {
+    return this.setLimit("max", e, !1, S.toString(r));
+  }
+  setLimit(e, r, s, n) {
+    return new Le({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: r,
+          inclusive: s,
+          message: S.toString(n)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new Le({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  int(e) {
+    return this._addCheck({
+      kind: "int",
+      message: S.toString(e)
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !1,
+      message: S.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !1,
+      message: S.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !0,
+      message: S.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !0,
+      message: S.toString(e)
+    });
+  }
+  multipleOf(e, r) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: S.toString(r)
+    });
+  }
+  finite(e) {
+    return this._addCheck({
+      kind: "finite",
+      message: S.toString(e)
+    });
+  }
+  safe(e) {
+    return this._addCheck({
+      kind: "min",
+      inclusive: !0,
+      value: Number.MIN_SAFE_INTEGER,
+      message: S.toString(e)
+    })._addCheck({
+      kind: "max",
+      inclusive: !0,
+      value: Number.MAX_SAFE_INTEGER,
+      message: S.toString(e)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "min" && (e === null || r.value > e) && (e = r.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+    return e;
+  }
+  get isInt() {
+    return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" && F.isInteger(e.value));
+  }
+  get isFinite() {
+    let e = null, r = null;
+    for (const s of this._def.checks) {
+      if (s.kind === "finite" || s.kind === "int" || s.kind === "multipleOf")
+        return !0;
+      s.kind === "min" ? (r === null || s.value > r) && (r = s.value) : s.kind === "max" && (e === null || s.value < e) && (e = s.value);
+    }
+    return Number.isFinite(r) && Number.isFinite(e);
+  }
+}
+Le.create = (t) => new Le({
+  checks: [],
+  typeName: E.ZodNumber,
+  coerce: (t == null ? void 0 : t.coerce) || !1,
+  ...N(t)
+});
+class $e extends O {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte;
+  }
+  _parse(e) {
+    if (this._def.coerce)
+      try {
+        e.data = BigInt(e.data);
+      } catch {
+        return this._getInvalidInput(e);
+      }
+    if (this._getType(e) !== T.bigint)
+      return this._getInvalidInput(e);
+    let s;
+    const n = new se();
+    for (const a of this._def.checks)
+      a.kind === "min" ? (a.inclusive ? e.data < a.value : e.data <= a.value) && (s = this._getOrReturnCtx(e, s), k(s, {
+        code: m.too_small,
+        type: "bigint",
+        minimum: a.value,
+        inclusive: a.inclusive,
+        message: a.message
+      }), n.dirty()) : a.kind === "max" ? (a.inclusive ? e.data > a.value : e.data >= a.value) && (s = this._getOrReturnCtx(e, s), k(s, {
+        code: m.too_big,
+        type: "bigint",
+        maximum: a.value,
+        inclusive: a.inclusive,
+        message: a.message
+      }), n.dirty()) : a.kind === "multipleOf" ? e.data % a.value !== BigInt(0) && (s = this._getOrReturnCtx(e, s), k(s, {
+        code: m.not_multiple_of,
+        multipleOf: a.value,
+        message: a.message
+      }), n.dirty()) : F.assertNever(a);
+    return { status: n.value, value: e.data };
+  }
+  _getInvalidInput(e) {
+    const r = this._getOrReturnCtx(e);
+    return k(r, {
+      code: m.invalid_type,
+      expected: T.bigint,
+      received: r.parsedType
+    }), j;
+  }
+  gte(e, r) {
+    return this.setLimit("min", e, !0, S.toString(r));
+  }
+  gt(e, r) {
+    return this.setLimit("min", e, !1, S.toString(r));
+  }
+  lte(e, r) {
+    return this.setLimit("max", e, !0, S.toString(r));
+  }
+  lt(e, r) {
+    return this.setLimit("max", e, !1, S.toString(r));
+  }
+  setLimit(e, r, s, n) {
+    return new $e({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: r,
+          inclusive: s,
+          message: S.toString(n)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new $e({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !1,
+      message: S.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !1,
+      message: S.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !0,
+      message: S.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !0,
+      message: S.toString(e)
+    });
+  }
+  multipleOf(e, r) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: S.toString(r)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "min" && (e === null || r.value > e) && (e = r.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+    return e;
+  }
+}
+$e.create = (t) => new $e({
+  checks: [],
+  typeName: E.ZodBigInt,
+  coerce: (t == null ? void 0 : t.coerce) ?? !1,
+  ...N(t)
+});
+class yt extends O {
+  _parse(e) {
+    if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== T.boolean) {
+      const s = this._getOrReturnCtx(e);
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.boolean,
+        received: s.parsedType
+      }), j;
+    }
+    return ie(e.data);
+  }
+}
+yt.create = (t) => new yt({
+  typeName: E.ZodBoolean,
+  coerce: (t == null ? void 0 : t.coerce) || !1,
+  ...N(t)
+});
+class He extends O {
+  _parse(e) {
+    if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== T.date) {
+      const a = this._getOrReturnCtx(e);
+      return k(a, {
+        code: m.invalid_type,
+        expected: T.date,
+        received: a.parsedType
+      }), j;
+    }
+    if (Number.isNaN(e.data.getTime())) {
+      const a = this._getOrReturnCtx(e);
+      return k(a, {
+        code: m.invalid_date
+      }), j;
+    }
+    const s = new se();
+    let n;
+    for (const a of this._def.checks)
+      a.kind === "min" ? e.data.getTime() < a.value && (n = this._getOrReturnCtx(e, n), k(n, {
+        code: m.too_small,
+        message: a.message,
+        inclusive: !0,
+        exact: !1,
+        minimum: a.value,
+        type: "date"
+      }), s.dirty()) : a.kind === "max" ? e.data.getTime() > a.value && (n = this._getOrReturnCtx(e, n), k(n, {
+        code: m.too_big,
+        message: a.message,
+        inclusive: !0,
+        exact: !1,
+        maximum: a.value,
+        type: "date"
+      }), s.dirty()) : F.assertNever(a);
+    return {
+      status: s.value,
+      value: new Date(e.data.getTime())
+    };
+  }
+  _addCheck(e) {
+    return new He({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  min(e, r) {
+    return this._addCheck({
+      kind: "min",
+      value: e.getTime(),
+      message: S.toString(r)
+    });
+  }
+  max(e, r) {
+    return this._addCheck({
+      kind: "max",
+      value: e.getTime(),
+      message: S.toString(r)
+    });
+  }
+  get minDate() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "min" && (e === null || r.value > e) && (e = r.value);
+    return e != null ? new Date(e) : null;
+  }
+  get maxDate() {
+    let e = null;
+    for (const r of this._def.checks)
+      r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+    return e != null ? new Date(e) : null;
+  }
+}
+He.create = (t) => new He({
+  checks: [],
+  coerce: (t == null ? void 0 : t.coerce) || !1,
+  typeName: E.ZodDate,
+  ...N(t)
+});
+class Lt extends O {
+  _parse(e) {
+    if (this._getType(e) !== T.symbol) {
+      const s = this._getOrReturnCtx(e);
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.symbol,
+        received: s.parsedType
+      }), j;
+    }
+    return ie(e.data);
+  }
+}
+Lt.create = (t) => new Lt({
+  typeName: E.ZodSymbol,
+  ...N(t)
+});
+class gt extends O {
+  _parse(e) {
+    if (this._getType(e) !== T.undefined) {
+      const s = this._getOrReturnCtx(e);
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.undefined,
+        received: s.parsedType
+      }), j;
+    }
+    return ie(e.data);
+  }
+}
+gt.create = (t) => new gt({
+  typeName: E.ZodUndefined,
+  ...N(t)
+});
+class vt extends O {
+  _parse(e) {
+    if (this._getType(e) !== T.null) {
+      const s = this._getOrReturnCtx(e);
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.null,
+        received: s.parsedType
+      }), j;
+    }
+    return ie(e.data);
+  }
+}
+vt.create = (t) => new vt({
+  typeName: E.ZodNull,
+  ...N(t)
+});
+class at extends O {
+  constructor() {
+    super(...arguments), this._any = !0;
+  }
+  _parse(e) {
+    return ie(e.data);
+  }
+}
+at.create = (t) => new at({
+  typeName: E.ZodAny,
+  ...N(t)
+});
+class Ye extends O {
+  constructor() {
+    super(...arguments), this._unknown = !0;
+  }
+  _parse(e) {
+    return ie(e.data);
+  }
+}
+Ye.create = (t) => new Ye({
+  typeName: E.ZodUnknown,
+  ...N(t)
+});
+class Fe extends O {
+  _parse(e) {
+    const r = this._getOrReturnCtx(e);
+    return k(r, {
+      code: m.invalid_type,
+      expected: T.never,
+      received: r.parsedType
+    }), j;
+  }
+}
+Fe.create = (t) => new Fe({
+  typeName: E.ZodNever,
+  ...N(t)
+});
+class $t extends O {
+  _parse(e) {
+    if (this._getType(e) !== T.undefined) {
+      const s = this._getOrReturnCtx(e);
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.void,
+        received: s.parsedType
+      }), j;
+    }
+    return ie(e.data);
+  }
+}
+$t.create = (t) => new $t({
+  typeName: E.ZodVoid,
+  ...N(t)
+});
+class _e extends O {
+  _parse(e) {
+    const { ctx: r, status: s } = this._processInputParams(e), n = this._def;
+    if (r.parsedType !== T.array)
+      return k(r, {
+        code: m.invalid_type,
+        expected: T.array,
+        received: r.parsedType
+      }), j;
+    if (n.exactLength !== null) {
+      const i = r.data.length > n.exactLength.value, o = r.data.length < n.exactLength.value;
+      (i || o) && (k(r, {
+        code: i ? m.too_big : m.too_small,
+        minimum: o ? n.exactLength.value : void 0,
+        maximum: i ? n.exactLength.value : void 0,
+        type: "array",
+        inclusive: !0,
+        exact: !0,
+        message: n.exactLength.message
+      }), s.dirty());
+    }
+    if (n.minLength !== null && r.data.length < n.minLength.value && (k(r, {
+      code: m.too_small,
+      minimum: n.minLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: n.minLength.message
+    }), s.dirty()), n.maxLength !== null && r.data.length > n.maxLength.value && (k(r, {
+      code: m.too_big,
+      maximum: n.maxLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: n.maxLength.message
+    }), s.dirty()), r.common.async)
+      return Promise.all([...r.data].map((i, o) => n.type._parseAsync(new Ae(r, i, r.path, o)))).then((i) => se.mergeArray(s, i));
+    const a = [...r.data].map((i, o) => n.type._parseSync(new Ae(r, i, r.path, o)));
+    return se.mergeArray(s, a);
+  }
+  get element() {
+    return this._def.type;
+  }
+  min(e, r) {
+    return new _e({
+      ...this._def,
+      minLength: { value: e, message: S.toString(r) }
+    });
+  }
+  max(e, r) {
+    return new _e({
+      ...this._def,
+      maxLength: { value: e, message: S.toString(r) }
+    });
+  }
+  length(e, r) {
+    return new _e({
+      ...this._def,
+      exactLength: { value: e, message: S.toString(r) }
+    });
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+_e.create = (t, e) => new _e({
+  type: t,
+  minLength: null,
+  maxLength: null,
+  exactLength: null,
+  typeName: E.ZodArray,
+  ...N(e)
+});
+function tt(t) {
+  if (t instanceof z) {
+    const e = {};
+    for (const r in t.shape) {
+      const s = t.shape[r];
+      e[r] = Se.create(tt(s));
+    }
+    return new z({
+      ...t._def,
+      shape: () => e
+    });
+  } else return t instanceof _e ? new _e({
+    ...t._def,
+    type: tt(t.element)
+  }) : t instanceof Se ? Se.create(tt(t.unwrap())) : t instanceof ze ? ze.create(tt(t.unwrap())) : t instanceof je ? je.create(t.items.map((e) => tt(e))) : t;
+}
+class z extends O {
+  constructor() {
+    super(...arguments), this._cached = null, this.nonstrict = this.passthrough, this.augment = this.extend;
+  }
+  _getCached() {
+    if (this._cached !== null)
+      return this._cached;
+    const e = this._def.shape(), r = F.objectKeys(e);
+    return this._cached = { shape: e, keys: r }, this._cached;
+  }
+  _parse(e) {
+    if (this._getType(e) !== T.object) {
+      const f = this._getOrReturnCtx(e);
+      return k(f, {
+        code: m.invalid_type,
+        expected: T.object,
+        received: f.parsedType
+      }), j;
+    }
+    const { status: s, ctx: n } = this._processInputParams(e), { shape: a, keys: i } = this._getCached(), o = [];
+    if (!(this._def.catchall instanceof Fe && this._def.unknownKeys === "strip"))
+      for (const f in n.data)
+        i.includes(f) || o.push(f);
+    const d = [];
+    for (const f of i) {
+      const _ = a[f], y = n.data[f];
+      d.push({
+        key: { status: "valid", value: f },
+        value: _._parse(new Ae(n, y, n.path, f)),
+        alwaysSet: f in n.data
+      });
+    }
+    if (this._def.catchall instanceof Fe) {
+      const f = this._def.unknownKeys;
+      if (f === "passthrough")
+        for (const _ of o)
+          d.push({
+            key: { status: "valid", value: _ },
+            value: { status: "valid", value: n.data[_] }
+          });
+      else if (f === "strict")
+        o.length > 0 && (k(n, {
+          code: m.unrecognized_keys,
+          keys: o
+        }), s.dirty());
+      else if (f !== "strip") throw new Error("Internal ZodObject error: invalid unknownKeys value.");
+    } else {
+      const f = this._def.catchall;
+      for (const _ of o) {
+        const y = n.data[_];
+        d.push({
+          key: { status: "valid", value: _ },
+          value: f._parse(
+            new Ae(n, y, n.path, _)
+            //, ctx.child(key), value, getParsedType(value)
+          ),
+          alwaysSet: _ in n.data
+        });
+      }
+    }
+    return n.common.async ? Promise.resolve().then(async () => {
+      const f = [];
+      for (const _ of d) {
+        const y = await _.key, v = await _.value;
+        f.push({
+          key: y,
+          value: v,
+          alwaysSet: _.alwaysSet
+        });
+      }
+      return f;
+    }).then((f) => se.mergeObjectSync(s, f)) : se.mergeObjectSync(s, d);
+  }
+  get shape() {
+    return this._def.shape();
+  }
+  strict(e) {
+    return S.errToObj, new z({
+      ...this._def,
+      unknownKeys: "strict",
+      ...e !== void 0 ? {
+        errorMap: (r, s) => {
+          var a, i;
+          const n = ((i = (a = this._def).errorMap) == null ? void 0 : i.call(a, r, s).message) ?? s.defaultError;
+          return r.code === "unrecognized_keys" ? {
+            message: S.errToObj(e).message ?? n
+          } : {
+            message: n
+          };
+        }
+      } : {}
+    });
+  }
+  strip() {
+    return new z({
+      ...this._def,
+      unknownKeys: "strip"
+    });
+  }
+  passthrough() {
+    return new z({
+      ...this._def,
+      unknownKeys: "passthrough"
+    });
+  }
+  // const AugmentFactory =
+  //   <Def extends ZodObjectDef>(def: Def) =>
+  //   <Augmentation extends ZodRawShape>(
+  //     augmentation: Augmentation
+  //   ): ZodObject<
+  //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
+  //     Def["unknownKeys"],
+  //     Def["catchall"]
+  //   > => {
+  //     return new ZodObject({
+  //       ...def,
+  //       shape: () => ({
+  //         ...def.shape(),
+  //         ...augmentation,
+  //       }),
+  //     }) as any;
+  //   };
+  extend(e) {
+    return new z({
+      ...this._def,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e
+      })
+    });
+  }
+  /**
+   * Prior to zod@1.0.12 there was a bug in the
+   * inferred type of merged objects. Please
+   * upgrade if you are experiencing issues.
+   */
+  merge(e) {
+    return new z({
+      unknownKeys: e._def.unknownKeys,
+      catchall: e._def.catchall,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e._def.shape()
+      }),
+      typeName: E.ZodObject
+    });
+  }
+  // merge<
+  //   Incoming extends AnyZodObject,
+  //   Augmentation extends Incoming["shape"],
+  //   NewOutput extends {
+  //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
+  //       ? Augmentation[k]["_output"]
+  //       : k extends keyof Output
+  //       ? Output[k]
+  //       : never;
+  //   },
+  //   NewInput extends {
+  //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
+  //       ? Augmentation[k]["_input"]
+  //       : k extends keyof Input
+  //       ? Input[k]
+  //       : never;
+  //   }
+  // >(
+  //   merging: Incoming
+  // ): ZodObject<
+  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
+  //   Incoming["_def"]["unknownKeys"],
+  //   Incoming["_def"]["catchall"],
+  //   NewOutput,
+  //   NewInput
+  // > {
+  //   const merged: any = new ZodObject({
+  //     unknownKeys: merging._def.unknownKeys,
+  //     catchall: merging._def.catchall,
+  //     shape: () =>
+  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+  //     typeName: ZodFirstPartyTypeKind.ZodObject,
+  //   }) as any;
+  //   return merged;
+  // }
+  setKey(e, r) {
+    return this.augment({ [e]: r });
+  }
+  // merge<Incoming extends AnyZodObject>(
+  //   merging: Incoming
+  // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
+  // ZodObject<
+  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
+  //   Incoming["_def"]["unknownKeys"],
+  //   Incoming["_def"]["catchall"]
+  // > {
+  //   // const mergedShape = objectUtil.mergeShapes(
+  //   //   this._def.shape(),
+  //   //   merging._def.shape()
+  //   // );
+  //   const merged: any = new ZodObject({
+  //     unknownKeys: merging._def.unknownKeys,
+  //     catchall: merging._def.catchall,
+  //     shape: () =>
+  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+  //     typeName: ZodFirstPartyTypeKind.ZodObject,
+  //   }) as any;
+  //   return merged;
+  // }
+  catchall(e) {
+    return new z({
+      ...this._def,
+      catchall: e
+    });
+  }
+  pick(e) {
+    const r = {};
+    for (const s of F.objectKeys(e))
+      e[s] && this.shape[s] && (r[s] = this.shape[s]);
+    return new z({
+      ...this._def,
+      shape: () => r
+    });
+  }
+  omit(e) {
+    const r = {};
+    for (const s of F.objectKeys(this.shape))
+      e[s] || (r[s] = this.shape[s]);
+    return new z({
+      ...this._def,
+      shape: () => r
+    });
+  }
+  /**
+   * @deprecated
+   */
+  deepPartial() {
+    return tt(this);
+  }
+  partial(e) {
+    const r = {};
+    for (const s of F.objectKeys(this.shape)) {
+      const n = this.shape[s];
+      e && !e[s] ? r[s] = n : r[s] = n.optional();
+    }
+    return new z({
+      ...this._def,
+      shape: () => r
+    });
+  }
+  required(e) {
+    const r = {};
+    for (const s of F.objectKeys(this.shape))
+      if (e && !e[s])
+        r[s] = this.shape[s];
+      else {
+        let a = this.shape[s];
+        for (; a instanceof Se; )
+          a = a._def.innerType;
+        r[s] = a;
+      }
+    return new z({
+      ...this._def,
+      shape: () => r
+    });
+  }
+  keyof() {
+    return as(F.objectKeys(this.shape));
+  }
+}
+z.create = (t, e) => new z({
+  shape: () => t,
+  unknownKeys: "strip",
+  catchall: Fe.create(),
+  typeName: E.ZodObject,
+  ...N(e)
+});
+z.strictCreate = (t, e) => new z({
+  shape: () => t,
+  unknownKeys: "strict",
+  catchall: Fe.create(),
+  typeName: E.ZodObject,
+  ...N(e)
+});
+z.lazycreate = (t, e) => new z({
+  shape: t,
+  unknownKeys: "strip",
+  catchall: Fe.create(),
+  typeName: E.ZodObject,
+  ...N(e)
+});
+class _t extends O {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e), s = this._def.options;
+    function n(a) {
+      for (const o of a)
+        if (o.result.status === "valid")
+          return o.result;
+      for (const o of a)
+        if (o.result.status === "dirty")
+          return r.common.issues.push(...o.ctx.common.issues), o.result;
+      const i = a.map((o) => new he(o.ctx.common.issues));
+      return k(r, {
+        code: m.invalid_union,
+        unionErrors: i
+      }), j;
+    }
+    if (r.common.async)
+      return Promise.all(s.map(async (a) => {
+        const i = {
+          ...r,
+          common: {
+            ...r.common,
+            issues: []
+          },
+          parent: null
+        };
+        return {
+          result: await a._parseAsync({
+            data: r.data,
+            path: r.path,
+            parent: i
+          }),
+          ctx: i
+        };
+      })).then(n);
+    {
+      let a;
+      const i = [];
+      for (const d of s) {
+        const f = {
+          ...r,
+          common: {
+            ...r.common,
+            issues: []
+          },
+          parent: null
+        }, _ = d._parseSync({
+          data: r.data,
+          path: r.path,
+          parent: f
+        });
+        if (_.status === "valid")
+          return _;
+        _.status === "dirty" && !a && (a = { result: _, ctx: f }), f.common.issues.length && i.push(f.common.issues);
+      }
+      if (a)
+        return r.common.issues.push(...a.ctx.common.issues), a.result;
+      const o = i.map((d) => new he(d));
+      return k(r, {
+        code: m.invalid_union,
+        unionErrors: o
+      }), j;
+    }
+  }
+  get options() {
+    return this._def.options;
+  }
+}
+_t.create = (t, e) => new _t({
+  options: t,
+  typeName: E.ZodUnion,
+  ...N(e)
+});
+const Oe = (t) => t instanceof kt ? Oe(t.schema) : t instanceof be ? Oe(t.innerType()) : t instanceof wt ? [t.value] : t instanceof Ue ? t.options : t instanceof Tt ? F.objectValues(t.enum) : t instanceof St ? Oe(t._def.innerType) : t instanceof gt ? [void 0] : t instanceof vt ? [null] : t instanceof Se ? [void 0, ...Oe(t.unwrap())] : t instanceof ze ? [null, ...Oe(t.unwrap())] : t instanceof dr || t instanceof jt ? Oe(t.unwrap()) : t instanceof At ? Oe(t._def.innerType) : [];
+class qt extends O {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== T.object)
+      return k(r, {
+        code: m.invalid_type,
+        expected: T.object,
+        received: r.parsedType
+      }), j;
+    const s = this.discriminator, n = r.data[s], a = this.optionsMap.get(n);
+    return a ? r.common.async ? a._parseAsync({
+      data: r.data,
+      path: r.path,
+      parent: r
+    }) : a._parseSync({
+      data: r.data,
+      path: r.path,
+      parent: r
+    }) : (k(r, {
+      code: m.invalid_union_discriminator,
+      options: Array.from(this.optionsMap.keys()),
+      path: [s]
+    }), j);
+  }
+  get discriminator() {
+    return this._def.discriminator;
+  }
+  get options() {
+    return this._def.options;
+  }
+  get optionsMap() {
+    return this._def.optionsMap;
+  }
+  /**
+   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+   * have a different value for each object in the union.
+   * @param discriminator the name of the discriminator property
+   * @param types an array of object schemas
+   * @param params
+   */
+  static create(e, r, s) {
+    const n = /* @__PURE__ */ new Map();
+    for (const a of r) {
+      const i = Oe(a.shape[e]);
+      if (!i.length)
+        throw new Error(`A discriminator value for key \`${e}\` could not be extracted from all schema options`);
+      for (const o of i) {
+        if (n.has(o))
+          throw new Error(`Discriminator property ${String(e)} has duplicate value ${String(o)}`);
+        n.set(o, a);
+      }
+    }
+    return new qt({
+      typeName: E.ZodDiscriminatedUnion,
+      discriminator: e,
+      options: r,
+      optionsMap: n,
+      ...N(s)
+    });
+  }
+}
+function sr(t, e) {
+  const r = Ve(t), s = Ve(e);
+  if (t === e)
+    return { valid: !0, data: t };
+  if (r === T.object && s === T.object) {
+    const n = F.objectKeys(e), a = F.objectKeys(t).filter((o) => n.indexOf(o) !== -1), i = { ...t, ...e };
+    for (const o of a) {
+      const d = sr(t[o], e[o]);
+      if (!d.valid)
+        return { valid: !1 };
+      i[o] = d.data;
+    }
+    return { valid: !0, data: i };
+  } else if (r === T.array && s === T.array) {
+    if (t.length !== e.length)
+      return { valid: !1 };
+    const n = [];
+    for (let a = 0; a < t.length; a++) {
+      const i = t[a], o = e[a], d = sr(i, o);
+      if (!d.valid)
+        return { valid: !1 };
+      n.push(d.data);
+    }
+    return { valid: !0, data: n };
+  } else return r === T.date && s === T.date && +t == +e ? { valid: !0, data: t } : { valid: !1 };
+}
+class bt extends O {
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e), n = (a, i) => {
+      if (tr(a) || tr(i))
+        return j;
+      const o = sr(a.value, i.value);
+      return o.valid ? ((rr(a) || rr(i)) && r.dirty(), { status: r.value, value: o.data }) : (k(s, {
+        code: m.invalid_intersection_types
+      }), j);
+    };
+    return s.common.async ? Promise.all([
+      this._def.left._parseAsync({
+        data: s.data,
+        path: s.path,
+        parent: s
+      }),
+      this._def.right._parseAsync({
+        data: s.data,
+        path: s.path,
+        parent: s
+      })
+    ]).then(([a, i]) => n(a, i)) : n(this._def.left._parseSync({
+      data: s.data,
+      path: s.path,
+      parent: s
+    }), this._def.right._parseSync({
+      data: s.data,
+      path: s.path,
+      parent: s
+    }));
+  }
+}
+bt.create = (t, e, r) => new bt({
+  left: t,
+  right: e,
+  typeName: E.ZodIntersection,
+  ...N(r)
+});
+class je extends O {
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== T.array)
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.array,
+        received: s.parsedType
+      }), j;
+    if (s.data.length < this._def.items.length)
+      return k(s, {
+        code: m.too_small,
+        minimum: this._def.items.length,
+        inclusive: !0,
+        exact: !1,
+        type: "array"
+      }), j;
+    !this._def.rest && s.data.length > this._def.items.length && (k(s, {
+      code: m.too_big,
+      maximum: this._def.items.length,
+      inclusive: !0,
+      exact: !1,
+      type: "array"
+    }), r.dirty());
+    const a = [...s.data].map((i, o) => {
+      const d = this._def.items[o] || this._def.rest;
+      return d ? d._parse(new Ae(s, i, s.path, o)) : null;
+    }).filter((i) => !!i);
+    return s.common.async ? Promise.all(a).then((i) => se.mergeArray(r, i)) : se.mergeArray(r, a);
+  }
+  get items() {
+    return this._def.items;
+  }
+  rest(e) {
+    return new je({
+      ...this._def,
+      rest: e
+    });
+  }
+}
+je.create = (t, e) => {
+  if (!Array.isArray(t))
+    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+  return new je({
+    items: t,
+    typeName: E.ZodTuple,
+    rest: null,
+    ...N(e)
+  });
+};
+class xt extends O {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== T.object)
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.object,
+        received: s.parsedType
+      }), j;
+    const n = [], a = this._def.keyType, i = this._def.valueType;
+    for (const o in s.data)
+      n.push({
+        key: a._parse(new Ae(s, o, s.path, o)),
+        value: i._parse(new Ae(s, s.data[o], s.path, o)),
+        alwaysSet: o in s.data
+      });
+    return s.common.async ? se.mergeObjectAsync(r, n) : se.mergeObjectSync(r, n);
+  }
+  get element() {
+    return this._def.valueType;
+  }
+  static create(e, r, s) {
+    return r instanceof O ? new xt({
+      keyType: e,
+      valueType: r,
+      typeName: E.ZodRecord,
+      ...N(s)
+    }) : new xt({
+      keyType: ve.create(),
+      valueType: e,
+      typeName: E.ZodRecord,
+      ...N(r)
+    });
+  }
+}
+class Ut extends O {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== T.map)
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.map,
+        received: s.parsedType
+      }), j;
+    const n = this._def.keyType, a = this._def.valueType, i = [...s.data.entries()].map(([o, d], f) => ({
+      key: n._parse(new Ae(s, o, s.path, [f, "key"])),
+      value: a._parse(new Ae(s, d, s.path, [f, "value"]))
+    }));
+    if (s.common.async) {
+      const o = /* @__PURE__ */ new Map();
+      return Promise.resolve().then(async () => {
+        for (const d of i) {
+          const f = await d.key, _ = await d.value;
+          if (f.status === "aborted" || _.status === "aborted")
+            return j;
+          (f.status === "dirty" || _.status === "dirty") && r.dirty(), o.set(f.value, _.value);
+        }
+        return { status: r.value, value: o };
+      });
+    } else {
+      const o = /* @__PURE__ */ new Map();
+      for (const d of i) {
+        const f = d.key, _ = d.value;
+        if (f.status === "aborted" || _.status === "aborted")
+          return j;
+        (f.status === "dirty" || _.status === "dirty") && r.dirty(), o.set(f.value, _.value);
+      }
+      return { status: r.value, value: o };
+    }
+  }
+}
+Ut.create = (t, e, r) => new Ut({
+  valueType: e,
+  keyType: t,
+  typeName: E.ZodMap,
+  ...N(r)
+});
+class Ge extends O {
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.parsedType !== T.set)
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.set,
+        received: s.parsedType
+      }), j;
+    const n = this._def;
+    n.minSize !== null && s.data.size < n.minSize.value && (k(s, {
+      code: m.too_small,
+      minimum: n.minSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: n.minSize.message
+    }), r.dirty()), n.maxSize !== null && s.data.size > n.maxSize.value && (k(s, {
+      code: m.too_big,
+      maximum: n.maxSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: n.maxSize.message
+    }), r.dirty());
+    const a = this._def.valueType;
+    function i(d) {
+      const f = /* @__PURE__ */ new Set();
+      for (const _ of d) {
+        if (_.status === "aborted")
+          return j;
+        _.status === "dirty" && r.dirty(), f.add(_.value);
+      }
+      return { status: r.value, value: f };
+    }
+    const o = [...s.data.values()].map((d, f) => a._parse(new Ae(s, d, s.path, f)));
+    return s.common.async ? Promise.all(o).then((d) => i(d)) : i(o);
+  }
+  min(e, r) {
+    return new Ge({
+      ...this._def,
+      minSize: { value: e, message: S.toString(r) }
+    });
+  }
+  max(e, r) {
+    return new Ge({
+      ...this._def,
+      maxSize: { value: e, message: S.toString(r) }
+    });
+  }
+  size(e, r) {
+    return this.min(e, r).max(e, r);
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+Ge.create = (t, e) => new Ge({
+  valueType: t,
+  minSize: null,
+  maxSize: null,
+  typeName: E.ZodSet,
+  ...N(e)
+});
+class st extends O {
+  constructor() {
+    super(...arguments), this.validate = this.implement;
+  }
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== T.function)
+      return k(r, {
+        code: m.invalid_type,
+        expected: T.function,
+        received: r.parsedType
+      }), j;
+    function s(o, d) {
+      return Zt({
+        data: o,
+        path: r.path,
+        errorMaps: [r.common.contextualErrorMap, r.schemaErrorMap, Mt(), nt].filter((f) => !!f),
+        issueData: {
+          code: m.invalid_arguments,
+          argumentsError: d
+        }
+      });
+    }
+    function n(o, d) {
+      return Zt({
+        data: o,
+        path: r.path,
+        errorMaps: [r.common.contextualErrorMap, r.schemaErrorMap, Mt(), nt].filter((f) => !!f),
+        issueData: {
+          code: m.invalid_return_type,
+          returnTypeError: d
+        }
+      });
+    }
+    const a = { errorMap: r.common.contextualErrorMap }, i = r.data;
+    if (this._def.returns instanceof it) {
+      const o = this;
+      return ie(async function(...d) {
+        const f = new he([]), _ = await o._def.args.parseAsync(d, a).catch((W) => {
+          throw f.addIssue(s(d, W)), f;
+        }), y = await Reflect.apply(i, this, _);
+        return await o._def.returns._def.type.parseAsync(y, a).catch((W) => {
+          throw f.addIssue(n(y, W)), f;
+        });
+      });
+    } else {
+      const o = this;
+      return ie(function(...d) {
+        const f = o._def.args.safeParse(d, a);
+        if (!f.success)
+          throw new he([s(d, f.error)]);
+        const _ = Reflect.apply(i, this, f.data), y = o._def.returns.safeParse(_, a);
+        if (!y.success)
+          throw new he([n(_, y.error)]);
+        return y.data;
+      });
+    }
+  }
+  parameters() {
+    return this._def.args;
+  }
+  returnType() {
+    return this._def.returns;
+  }
+  args(...e) {
+    return new st({
+      ...this._def,
+      args: je.create(e).rest(Ye.create())
+    });
+  }
+  returns(e) {
+    return new st({
+      ...this._def,
+      returns: e
+    });
+  }
+  implement(e) {
+    return this.parse(e);
+  }
+  strictImplement(e) {
+    return this.parse(e);
+  }
+  static create(e, r, s) {
+    return new st({
+      args: e || je.create([]).rest(Ye.create()),
+      returns: r || Ye.create(),
+      typeName: E.ZodFunction,
+      ...N(s)
+    });
+  }
+}
+class kt extends O {
+  get schema() {
+    return this._def.getter();
+  }
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    return this._def.getter()._parse({ data: r.data, path: r.path, parent: r });
+  }
+}
+kt.create = (t, e) => new kt({
+  getter: t,
+  typeName: E.ZodLazy,
+  ...N(e)
+});
+class wt extends O {
+  _parse(e) {
+    if (e.data !== this._def.value) {
+      const r = this._getOrReturnCtx(e);
+      return k(r, {
+        received: r.data,
+        code: m.invalid_literal,
+        expected: this._def.value
+      }), j;
+    }
+    return { status: "valid", value: e.data };
+  }
+  get value() {
+    return this._def.value;
+  }
+}
+wt.create = (t, e) => new wt({
+  value: t,
+  typeName: E.ZodLiteral,
+  ...N(e)
+});
+function as(t, e) {
+  return new Ue({
+    values: t,
+    typeName: E.ZodEnum,
+    ...N(e)
+  });
+}
+class Ue extends O {
+  _parse(e) {
+    if (typeof e.data != "string") {
+      const r = this._getOrReturnCtx(e), s = this._def.values;
+      return k(r, {
+        expected: F.joinValues(s),
+        received: r.parsedType,
+        code: m.invalid_type
+      }), j;
+    }
+    if (this._cache || (this._cache = new Set(this._def.values)), !this._cache.has(e.data)) {
+      const r = this._getOrReturnCtx(e), s = this._def.values;
+      return k(r, {
+        received: r.data,
+        code: m.invalid_enum_value,
+        options: s
+      }), j;
+    }
+    return ie(e.data);
+  }
+  get options() {
+    return this._def.values;
+  }
+  get enum() {
+    const e = {};
+    for (const r of this._def.values)
+      e[r] = r;
+    return e;
+  }
+  get Values() {
+    const e = {};
+    for (const r of this._def.values)
+      e[r] = r;
+    return e;
+  }
+  get Enum() {
+    const e = {};
+    for (const r of this._def.values)
+      e[r] = r;
+    return e;
+  }
+  extract(e, r = this._def) {
+    return Ue.create(e, {
+      ...this._def,
+      ...r
+    });
+  }
+  exclude(e, r = this._def) {
+    return Ue.create(this.options.filter((s) => !e.includes(s)), {
+      ...this._def,
+      ...r
+    });
+  }
+}
+Ue.create = as;
+class Tt extends O {
+  _parse(e) {
+    const r = F.getValidEnumValues(this._def.values), s = this._getOrReturnCtx(e);
+    if (s.parsedType !== T.string && s.parsedType !== T.number) {
+      const n = F.objectValues(r);
+      return k(s, {
+        expected: F.joinValues(n),
+        received: s.parsedType,
+        code: m.invalid_type
+      }), j;
+    }
+    if (this._cache || (this._cache = new Set(F.getValidEnumValues(this._def.values))), !this._cache.has(e.data)) {
+      const n = F.objectValues(r);
+      return k(s, {
+        received: s.data,
+        code: m.invalid_enum_value,
+        options: n
+      }), j;
+    }
+    return ie(e.data);
+  }
+  get enum() {
+    return this._def.values;
+  }
+}
+Tt.create = (t, e) => new Tt({
+  values: t,
+  typeName: E.ZodNativeEnum,
+  ...N(e)
+});
+class it extends O {
+  unwrap() {
+    return this._def.type;
+  }
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== T.promise && r.common.async === !1)
+      return k(r, {
+        code: m.invalid_type,
+        expected: T.promise,
+        received: r.parsedType
+      }), j;
+    const s = r.parsedType === T.promise ? r.data : Promise.resolve(r.data);
+    return ie(s.then((n) => this._def.type.parseAsync(n, {
+      path: r.path,
+      errorMap: r.common.contextualErrorMap
+    })));
+  }
+}
+it.create = (t, e) => new it({
+  type: t,
+  typeName: E.ZodPromise,
+  ...N(e)
+});
+class be extends O {
+  innerType() {
+    return this._def.schema;
+  }
+  sourceType() {
+    return this._def.schema._def.typeName === E.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e), n = this._def.effect || null, a = {
+      addIssue: (i) => {
+        k(s, i), i.fatal ? r.abort() : r.dirty();
+      },
+      get path() {
+        return s.path;
+      }
+    };
+    if (a.addIssue = a.addIssue.bind(a), n.type === "preprocess") {
+      const i = n.transform(s.data, a);
+      if (s.common.async)
+        return Promise.resolve(i).then(async (o) => {
+          if (r.value === "aborted")
+            return j;
+          const d = await this._def.schema._parseAsync({
+            data: o,
+            path: s.path,
+            parent: s
+          });
+          return d.status === "aborted" ? j : d.status === "dirty" || r.value === "dirty" ? rt(d.value) : d;
+        });
+      {
+        if (r.value === "aborted")
+          return j;
+        const o = this._def.schema._parseSync({
+          data: i,
+          path: s.path,
+          parent: s
+        });
+        return o.status === "aborted" ? j : o.status === "dirty" || r.value === "dirty" ? rt(o.value) : o;
+      }
+    }
+    if (n.type === "refinement") {
+      const i = (o) => {
+        const d = n.refinement(o, a);
+        if (s.common.async)
+          return Promise.resolve(d);
+        if (d instanceof Promise)
+          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+        return o;
+      };
+      if (s.common.async === !1) {
+        const o = this._def.schema._parseSync({
+          data: s.data,
+          path: s.path,
+          parent: s
+        });
+        return o.status === "aborted" ? j : (o.status === "dirty" && r.dirty(), i(o.value), { status: r.value, value: o.value });
+      } else
+        return this._def.schema._parseAsync({ data: s.data, path: s.path, parent: s }).then((o) => o.status === "aborted" ? j : (o.status === "dirty" && r.dirty(), i(o.value).then(() => ({ status: r.value, value: o.value }))));
+    }
+    if (n.type === "transform")
+      if (s.common.async === !1) {
+        const i = this._def.schema._parseSync({
+          data: s.data,
+          path: s.path,
+          parent: s
+        });
+        if (!Je(i))
+          return j;
+        const o = n.transform(i.value, a);
+        if (o instanceof Promise)
+          throw new Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
+        return { status: r.value, value: o };
+      } else
+        return this._def.schema._parseAsync({ data: s.data, path: s.path, parent: s }).then((i) => Je(i) ? Promise.resolve(n.transform(i.value, a)).then((o) => ({
+          status: r.value,
+          value: o
+        })) : j);
+    F.assertNever(n);
+  }
+}
+be.create = (t, e, r) => new be({
+  schema: t,
+  typeName: E.ZodEffects,
+  effect: e,
+  ...N(r)
+});
+be.createWithPreprocess = (t, e, r) => new be({
+  schema: e,
+  effect: { type: "preprocess", transform: t },
+  typeName: E.ZodEffects,
+  ...N(r)
+});
+class Se extends O {
+  _parse(e) {
+    return this._getType(e) === T.undefined ? ie(void 0) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+Se.create = (t, e) => new Se({
+  innerType: t,
+  typeName: E.ZodOptional,
+  ...N(e)
+});
+class ze extends O {
+  _parse(e) {
+    return this._getType(e) === T.null ? ie(null) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+ze.create = (t, e) => new ze({
+  innerType: t,
+  typeName: E.ZodNullable,
+  ...N(e)
+});
+class St extends O {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e);
+    let s = r.data;
+    return r.parsedType === T.undefined && (s = this._def.defaultValue()), this._def.innerType._parse({
+      data: s,
+      path: r.path,
+      parent: r
+    });
+  }
+  removeDefault() {
+    return this._def.innerType;
+  }
+}
+St.create = (t, e) => new St({
+  innerType: t,
+  typeName: E.ZodDefault,
+  defaultValue: typeof e.default == "function" ? e.default : () => e.default,
+  ...N(e)
+});
+class At extends O {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e), s = {
+      ...r,
+      common: {
+        ...r.common,
+        issues: []
+      }
+    }, n = this._def.innerType._parse({
+      data: s.data,
+      path: s.path,
+      parent: {
+        ...s
+      }
+    });
+    return pt(n) ? n.then((a) => ({
+      status: "valid",
+      value: a.status === "valid" ? a.value : this._def.catchValue({
+        get error() {
+          return new he(s.common.issues);
+        },
+        input: s.data
+      })
+    })) : {
+      status: "valid",
+      value: n.status === "valid" ? n.value : this._def.catchValue({
+        get error() {
+          return new he(s.common.issues);
+        },
+        input: s.data
+      })
+    };
+  }
+  removeCatch() {
+    return this._def.innerType;
+  }
+}
+At.create = (t, e) => new At({
+  innerType: t,
+  typeName: E.ZodCatch,
+  catchValue: typeof e.catch == "function" ? e.catch : () => e.catch,
+  ...N(e)
+});
+class zt extends O {
+  _parse(e) {
+    if (this._getType(e) !== T.nan) {
+      const s = this._getOrReturnCtx(e);
+      return k(s, {
+        code: m.invalid_type,
+        expected: T.nan,
+        received: s.parsedType
+      }), j;
+    }
+    return { status: "valid", value: e.data };
+  }
+}
+zt.create = (t) => new zt({
+  typeName: E.ZodNaN,
+  ...N(t)
+});
+const En = Symbol("zod_brand");
+class dr extends O {
+  _parse(e) {
+    const { ctx: r } = this._processInputParams(e), s = r.data;
+    return this._def.type._parse({
+      data: s,
+      path: r.path,
+      parent: r
+    });
+  }
+  unwrap() {
+    return this._def.type;
+  }
+}
+class Ct extends O {
+  _parse(e) {
+    const { status: r, ctx: s } = this._processInputParams(e);
+    if (s.common.async)
+      return (async () => {
+        const a = await this._def.in._parseAsync({
+          data: s.data,
+          path: s.path,
+          parent: s
+        });
+        return a.status === "aborted" ? j : a.status === "dirty" ? (r.dirty(), rt(a.value)) : this._def.out._parseAsync({
+          data: a.value,
+          path: s.path,
+          parent: s
+        });
+      })();
+    {
+      const n = this._def.in._parseSync({
+        data: s.data,
+        path: s.path,
+        parent: s
+      });
+      return n.status === "aborted" ? j : n.status === "dirty" ? (r.dirty(), {
+        status: "dirty",
+        value: n.value
+      }) : this._def.out._parseSync({
+        data: n.value,
+        path: s.path,
+        parent: s
+      });
+    }
+  }
+  static create(e, r) {
+    return new Ct({
+      in: e,
+      out: r,
+      typeName: E.ZodPipeline
+    });
+  }
+}
+class jt extends O {
+  _parse(e) {
+    const r = this._def.innerType._parse(e), s = (n) => (Je(n) && (n.value = Object.freeze(n.value)), n);
+    return pt(r) ? r.then((n) => s(n)) : s(r);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+jt.create = (t, e) => new jt({
+  innerType: t,
+  typeName: E.ZodReadonly,
+  ...N(e)
+});
+function Mr(t, e) {
+  const r = typeof t == "function" ? t(e) : typeof t == "string" ? { message: t } : t;
+  return typeof r == "string" ? { message: r } : r;
+}
+function is(t, e = {}, r) {
+  return t ? at.create().superRefine((s, n) => {
+    const a = t(s);
+    if (a instanceof Promise)
+      return a.then((i) => {
+        if (!i) {
+          const o = Mr(e, s), d = o.fatal ?? r ?? !0;
+          n.addIssue({ code: "custom", ...o, fatal: d });
+        }
+      });
+    if (!a) {
+      const i = Mr(e, s), o = i.fatal ?? r ?? !0;
+      n.addIssue({ code: "custom", ...i, fatal: o });
+    }
+  }) : at.create();
+}
+const Nn = {
+  object: z.lazycreate
+};
+var E;
+(function(t) {
+  t.ZodString = "ZodString", t.ZodNumber = "ZodNumber", t.ZodNaN = "ZodNaN", t.ZodBigInt = "ZodBigInt", t.ZodBoolean = "ZodBoolean", t.ZodDate = "ZodDate", t.ZodSymbol = "ZodSymbol", t.ZodUndefined = "ZodUndefined", t.ZodNull = "ZodNull", t.ZodAny = "ZodAny", t.ZodUnknown = "ZodUnknown", t.ZodNever = "ZodNever", t.ZodVoid = "ZodVoid", t.ZodArray = "ZodArray", t.ZodObject = "ZodObject", t.ZodUnion = "ZodUnion", t.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", t.ZodIntersection = "ZodIntersection", t.ZodTuple = "ZodTuple", t.ZodRecord = "ZodRecord", t.ZodMap = "ZodMap", t.ZodSet = "ZodSet", t.ZodFunction = "ZodFunction", t.ZodLazy = "ZodLazy", t.ZodLiteral = "ZodLiteral", t.ZodEnum = "ZodEnum", t.ZodEffects = "ZodEffects", t.ZodNativeEnum = "ZodNativeEnum", t.ZodOptional = "ZodOptional", t.ZodNullable = "ZodNullable", t.ZodDefault = "ZodDefault", t.ZodCatch = "ZodCatch", t.ZodPromise = "ZodPromise", t.ZodBranded = "ZodBranded", t.ZodPipeline = "ZodPipeline", t.ZodReadonly = "ZodReadonly";
+})(E || (E = {}));
+const Cn = (t, e = {
+  message: `Input not instance of ${t.name}`
+}) => is((r) => r instanceof t, e), os = ve.create, cs = Le.create, Rn = zt.create, On = $e.create, ls = yt.create, Vn = He.create, Fn = Lt.create, Pn = gt.create, In = vt.create, Dn = at.create, Mn = Ye.create, Zn = Fe.create, Ln = $t.create, $n = _e.create, Un = z.create, zn = z.strictCreate, Bn = _t.create, Wn = qt.create, qn = bt.create, Yn = je.create, Jn = xt.create, Hn = Ut.create, Gn = Ge.create, Xn = st.create, Qn = kt.create, Kn = wt.create, ea = Ue.create, ta = Tt.create, ra = it.create, Zr = be.create, sa = Se.create, na = ze.create, aa = be.createWithPreprocess, ia = Ct.create, oa = () => os().optional(), ca = () => cs().optional(), la = () => ls().optional(), ua = {
+  string: (t) => ve.create({ ...t, coerce: !0 }),
+  number: (t) => Le.create({ ...t, coerce: !0 }),
+  boolean: (t) => yt.create({
+    ...t,
+    coerce: !0
+  }),
+  bigint: (t) => $e.create({ ...t, coerce: !0 }),
+  date: (t) => He.create({ ...t, coerce: !0 })
+}, da = j, Re = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BRAND: En,
+  DIRTY: rt,
+  EMPTY_PATH: an,
+  INVALID: j,
+  NEVER: da,
+  OK: ie,
+  ParseStatus: se,
+  Schema: O,
+  ZodAny: at,
+  ZodArray: _e,
+  ZodBigInt: $e,
+  ZodBoolean: yt,
+  ZodBranded: dr,
+  ZodCatch: At,
+  ZodDate: He,
+  ZodDefault: St,
+  ZodDiscriminatedUnion: qt,
+  ZodEffects: be,
+  ZodEnum: Ue,
+  ZodError: he,
+  get ZodFirstPartyTypeKind() {
+    return E;
+  },
+  ZodFunction: st,
+  ZodIntersection: bt,
+  ZodIssueCode: m,
+  ZodLazy: kt,
+  ZodLiteral: wt,
+  ZodMap: Ut,
+  ZodNaN: zt,
+  ZodNativeEnum: Tt,
+  ZodNever: Fe,
+  ZodNull: vt,
+  ZodNullable: ze,
+  ZodNumber: Le,
+  ZodObject: z,
+  ZodOptional: Se,
+  ZodParsedType: T,
+  ZodPipeline: Ct,
+  ZodPromise: it,
+  ZodReadonly: jt,
+  ZodRecord: xt,
+  ZodSchema: O,
+  ZodSet: Ge,
+  ZodString: ve,
+  ZodSymbol: Lt,
+  ZodTransformer: be,
+  ZodTuple: je,
+  ZodType: O,
+  ZodUndefined: gt,
+  ZodUnion: _t,
+  ZodUnknown: Ye,
+  ZodVoid: $t,
+  addIssueToContext: k,
+  any: Dn,
+  array: $n,
+  bigint: On,
+  boolean: ls,
+  coerce: ua,
+  custom: is,
+  date: Vn,
+  datetimeRegex: ns,
+  defaultErrorMap: nt,
+  discriminatedUnion: Wn,
+  effect: Zr,
+  enum: ea,
+  function: Xn,
+  getErrorMap: Mt,
+  getParsedType: Ve,
+  instanceof: Cn,
+  intersection: qn,
+  isAborted: tr,
+  isAsync: pt,
+  isDirty: rr,
+  isValid: Je,
+  late: Nn,
+  lazy: Qn,
+  literal: Kn,
+  makeIssue: Zt,
+  map: Hn,
+  nan: Rn,
+  nativeEnum: ta,
+  never: Zn,
+  null: In,
+  nullable: na,
+  number: cs,
+  object: Un,
+  get objectUtil() {
+    return er;
+  },
+  oboolean: la,
+  onumber: ca,
+  optional: sa,
+  ostring: oa,
+  pipeline: ia,
+  preprocess: aa,
+  promise: ra,
+  quotelessJson: sn,
+  record: Jn,
+  set: Gn,
+  setErrorMap: nn,
+  strictObject: zn,
+  string: os,
+  symbol: Fn,
+  transformer: Zr,
+  tuple: Yn,
+  undefined: Pn,
+  union: Bn,
+  unknown: Mn,
+  get util() {
+    return F;
+  },
+  void: Ln
+}, Symbol.toStringTag, { value: "Module" })), Bt = (t) => /* @__PURE__ */ p.jsx(
+  "button",
+  {
+    type: t.type || "button",
+    disabled: t.isDisabled,
+    className: `bg-green-500 hover:bg-green-600 text-white px-6 py-2 rounded disabled:opacity-50 *:disabled:cursor-not-allowed ${t.className}`,
+    onClick: t.handleClick,
+    children: t.title
+  }
+), fa = ({
+  label: t,
+  required: e = !1,
+  file: r,
+  onFileChange: s,
+  error: n
+}) => {
+  const a = ys(null), [i, o] = Qt(null), [d, f] = Qt(!1), _ = (v) => {
+    var te;
+    const W = (te = v.target.files) == null ? void 0 : te[0];
+    W && (s(W), o(URL.createObjectURL(W)));
+  }, y = gs(() => {
+    var v;
+    (v = a.current) == null || v.click();
+  }, []);
+  return vs(() => {
+    r && o(URL.createObjectURL(r));
+  }, [r]), /* @__PURE__ */ p.jsxs(p.Fragment, { children: [
+    /* @__PURE__ */ p.jsxs("div", { className: "flex flex-col", children: [
+      /* @__PURE__ */ p.jsxs("label", { className: "font-medium mb-1 text-gray-700", children: [
+        t,
+        e && /* @__PURE__ */ p.jsx("span", { className: "text-red-500 ml-1", children: "*" })
+      ] }),
+      /* @__PURE__ */ p.jsxs("div", { className: "flex items-center", children: [
+        /* @__PURE__ */ p.jsx(
+          "button",
+          {
+            type: "button",
+            onClick: y,
+            className: "bg-green-500 hover:bg-green-600 text-white px-4 py-2 rounded",
+            children: "Upload file"
+          }
+        ),
+        /* @__PURE__ */ p.jsx(
+          "input",
+          {
+            ref: a,
+            type: "file",
+            accept: "image/*,.pdf",
+            className: "hidden",
+            onChange: _
+          }
+        )
+      ] }),
+      /* @__PURE__ */ p.jsx(
+        "div",
+        {
+          className: "mt-2 h-40 w-full bg-gray-200 rounded overflow-hidden flex items-center justify-center cursor-pointer",
+          onClick: () => i && f(!0),
+          children: i ? (r == null ? void 0 : r.type) === "application/pdf" ? /* @__PURE__ */ p.jsx(
+            "object",
+            {
+              data: i,
+              type: "application/pdf",
+              width: "100%",
+              height: "100%",
+              children: /* @__PURE__ */ p.jsxs("p", { className: "text-gray-600 text-sm", children: [
+                "Cannot preview PDF.",
+                " ",
+                /* @__PURE__ */ p.jsx(
+                  "a",
+                  {
+                    href: i,
+                    target: "_blank",
+                    rel: "noreferrer",
+                    className: "text-blue-600 underline",
+                    children: "Download PDF"
+                  }
+                )
+              ] })
+            }
+          ) : /* @__PURE__ */ p.jsx(
+            "img",
+            {
+              src: i,
+              alt: "Preview",
+              className: "h-full object-contain"
+            }
+          ) : /* @__PURE__ */ p.jsx("span", { className: "text-gray-500", children: "No file selected" })
+        }
+      ),
+      n && /* @__PURE__ */ p.jsx("span", { className: "text-red-500 text-sm mt-1", children: n })
+    ] }),
+    d && i && /* @__PURE__ */ p.jsx(
+      "div",
+      {
+        className: "fixed inset-0 bg-black bg-opacity-75 z-50 flex items-center justify-center",
+        onClick: () => f(!1),
+        children: /* @__PURE__ */ p.jsxs(
+          "div",
+          {
+            className: "relative w-full h-full",
+            onClick: (v) => v.stopPropagation(),
+            children: [
+              /* @__PURE__ */ p.jsx(
+                "button",
+                {
+                  onClick: () => f(!1),
+                  className: "absolute top-2 right-2 text-white text-2xl",
+                  "aria-label": "Close preview",
+                  children: "×"
+                }
+              ),
+              (r == null ? void 0 : r.type) === "application/pdf" ? /* @__PURE__ */ p.jsx(
+                "object",
+                {
+                  data: i,
+                  type: "application/pdf",
+                  className: "w-full h-full object-contain"
+                }
+              ) : /* @__PURE__ */ p.jsx(
+                "img",
+                {
+                  src: i,
+                  alt: "Full Preview",
+                  className: "w-full h-full object-contain"
+                }
+              )
+            ]
+          }
+        )
+      }
+    )
+  ] });
+}, Me = _s(
+  ({ label: t, required: e = !1, error: r, ...s }, n) => /* @__PURE__ */ p.jsxs("div", { className: "flex flex-col", children: [
+    /* @__PURE__ */ p.jsxs(
+      "label",
+      {
+        htmlFor: s.name,
+        className: "font-medium mb-1 text-gray-700",
+        children: [
+          t,
+          e && /* @__PURE__ */ p.jsx("span", { className: "text-red-500 ml-1", children: "*" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ p.jsx(
+      "input",
+      {
+        id: s.name,
+        ref: n,
+        ...s,
+        className: `border rounded px-3 py-2 focus:outline-none focus:ring-2 focus:ring-blue-500 ${r ? "border-red-500" : "border-gray-300"}`
+      }
+    ),
+    r && /* @__PURE__ */ p.jsx("span", { className: "text-red-500 text-sm mt-1", children: r })
+  ] })
+);
+Me.displayName = "InputField";
+const Et = Lr((t) => ({
+  selectedProvider: null,
+  form: {
+    taxCode: "",
+    companyName: "",
+    representative: "",
+    position: "",
+    email: "",
+    phoneNumber: null,
+    address: "",
+    license: null
+  },
+  selectedPlan: null,
+  setSelectedProvider: (e) => t({ selectedProvider: e }),
+  setForm: (e) => t((r) => ({
+    form: { ...r.form, ...e }
+  })),
+  setSelectedPlan: (e) => t({ selectedPlan: e }),
+  reset: () => t({
+    selectedProvider: null,
+    form: {
+      taxCode: "",
+      companyName: "",
+      representative: "",
+      position: "",
+      email: "",
+      phoneNumber: null,
+      address: "",
+      license: null
+    },
+    selectedPlan: null
+  })
+})), ha = Re.object({
+  taxCode: Re.string().nonempty("Mã số thuế là bắt buộc"),
+  representative: Re.string().nonempty("Người đại diện là bắt buộc"),
+  email: Re.string().nonempty("Email là bắt buộc").email("Email không hợp lệ"),
+  address: Re.string().nonempty("Địa chỉ là bắt buộc"),
+  companyName: Re.string().nonempty("Tên công ty là bắt buộc"),
+  position: Re.string().optional(),
+  phone: Re.string().regex(/^[0-9()+\-\s]+$/, "SĐT không hợp lệ").optional(),
+  // ← here we make it `.optional()`
+  license: Re.instanceof(File, {
+    message: "Giấy phép đăng ký kinh doanh là bắt buộc"
+  }).optional()
+}), ma = () => {
+  const t = nr(), e = Et((y) => y.form), {
+    control: r,
+    handleSubmit: s,
+    formState: { errors: n, isSubmitting: a, isValid: i }
+  } = Qs({
+    resolver: rn(ha),
+    defaultValues: {
+      taxCode: e.taxCode || "",
+      representative: e.representative || "",
+      email: e.email || "",
+      address: e.address || "",
+      companyName: e.companyName || "",
+      position: e.position || "",
+      phone: e.phoneNumber || "",
+      license: e.license || void 0
+      // handle optional license
+    }
+  }), o = Et((y) => y.setForm), d = mt((y) => y.nextStep), f = mt((y) => y.prevStep), _ = (y) => {
+    console.log(y), o({
+      taxCode: y.taxCode,
+      representative: y.representative,
+      email: y.email,
+      address: y.address,
+      companyName: y.companyName,
+      position: y.position,
+      phoneNumber: y.phone || null,
+      // handle optional phone
+      license: y.license || null
+      // handle optional license
+    });
+  };
+  return /* @__PURE__ */ p.jsxs(
+    "form",
+    {
+      onSubmit: s(_),
+      className: "w-full mx-auto p-6 bg-white shadow rounded",
+      children: [
+        /* @__PURE__ */ p.jsxs("div", { className: "grid grid-cols-1 md:grid-cols-2 gap-8", children: [
+          /* @__PURE__ */ p.jsxs("div", { className: "space-y-4", children: [
+            /* @__PURE__ */ p.jsx(
+              De,
+              {
+                name: "taxCode",
+                control: r,
+                render: ({ field: y }) => {
+                  var v;
+                  return /* @__PURE__ */ p.jsx(
+                    Me,
+                    {
+                      ...y,
+                      label: "Mã số thuế",
+                      required: !0,
+                      error: (v = n.taxCode) == null ? void 0 : v.message
+                    }
+                  );
+                }
+              }
+            ),
+            /* @__PURE__ */ p.jsx(
+              De,
+              {
+                name: "representative",
+                control: r,
+                render: ({ field: y }) => {
+                  var v;
+                  return /* @__PURE__ */ p.jsx(
+                    Me,
+                    {
+                      ...y,
+                      label: "Người đại diện",
+                      required: !0,
+                      error: (v = n.representative) == null ? void 0 : v.message
+                    }
+                  );
+                }
+              }
+            ),
+            /* @__PURE__ */ p.jsx(
+              De,
+              {
+                name: "email",
+                control: r,
+                render: ({ field: y }) => {
+                  var v;
+                  return /* @__PURE__ */ p.jsx(
+                    Me,
+                    {
+                      ...y,
+                      label: "Email",
+                      type: "email",
+                      required: !0,
+                      error: (v = n.email) == null ? void 0 : v.message
+                    }
+                  );
+                }
+              }
+            ),
+            /* @__PURE__ */ p.jsx(
+              De,
+              {
+                name: "address",
+                control: r,
+                render: ({ field: y }) => {
+                  var v;
+                  return /* @__PURE__ */ p.jsx(
+                    Me,
+                    {
+                      ...y,
+                      label: "Địa chỉ",
+                      required: !0,
+                      error: (v = n.address) == null ? void 0 : v.message
+                    }
+                  );
+                }
+              }
+            ),
+            /* @__PURE__ */ p.jsx(
+              De,
+              {
+                name: "license",
+                control: r,
+                render: ({ field: y }) => {
+                  var v;
+                  return /* @__PURE__ */ p.jsx(
+                    fa,
+                    {
+                      label: "Giấy phép đăng ký kinh doanh",
+                      required: !0,
+                      file: y.value ?? null,
+                      onFileChange: y.onChange,
+                      error: (v = n.license) == null ? void 0 : v.message
+                    }
+                  );
+                }
+              }
+            )
+          ] }),
+          /* @__PURE__ */ p.jsxs("div", { className: "space-y-4", children: [
+            /* @__PURE__ */ p.jsx(
+              De,
+              {
+                name: "companyName",
+                control: r,
+                render: ({ field: y }) => {
+                  var v;
+                  return /* @__PURE__ */ p.jsx(
+                    Me,
+                    {
+                      ...y,
+                      label: "Tên công ty",
+                      required: !0,
+                      error: (v = n.companyName) == null ? void 0 : v.message
+                    }
+                  );
+                }
+              }
+            ),
+            /* @__PURE__ */ p.jsx(
+              De,
+              {
+                name: "position",
+                control: r,
+                render: ({ field: y }) => {
+                  var v;
+                  return /* @__PURE__ */ p.jsx(
+                    Me,
+                    {
+                      ...y,
+                      label: "Chức vụ",
+                      error: (v = n.position) == null ? void 0 : v.message
+                    }
+                  );
+                }
+              }
+            ),
+            /* @__PURE__ */ p.jsx(
+              De,
+              {
+                name: "phone",
+                control: r,
+                render: ({ field: y }) => {
+                  var v;
+                  return /* @__PURE__ */ p.jsx(
+                    Me,
+                    {
+                      ...y,
+                      label: "SĐT",
+                      type: "tel",
+                      error: (v = n.phone) == null ? void 0 : v.message
+                    }
+                  );
+                }
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ p.jsxs("div", { className: "flex items-center justify-end gap-2", children: [
+          /* @__PURE__ */ p.jsx(
+            Bt,
+            {
+              title: "Back",
+              handleClick: () => {
+                f(), t("/select-provider");
+              },
+              className: " !bg-gray-200 !text-gray-700 hover:!bg-gray-300 disabled:!bg-gray-200 disabled:!text-gray-500"
+            }
+          ),
+          /* @__PURE__ */ p.jsx(
+            Bt,
+            {
+              type: "submit",
+              title: a ? "Submitting..." : "Submit",
+              isDisabled: a || Object.keys(n).length > 0 || !i,
+              handleClick: () => {
+                d(), t("/select-plan");
+              }
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}, pa = ({
+  options: t,
+  value: e,
+  onChange: r
+}) => /* @__PURE__ */ p.jsx(
+  "fieldset",
+  {
+    role: "radiogroup",
+    "aria-label": "Chọn gói đăng ký",
+    className: "flex flex-col md:flex-row gap-4 md:gap-20",
+    children: t.map((s) => {
+      const n = s.value === e;
+      return /* @__PURE__ */ p.jsxs(
+        "label",
+        {
+          className: [
+            "flex items-center cursor-pointer rounded-lg border p-4 transition",
+            n ? "border-green-500 bg-green-50" : "border-gray-300 bg-white hover:bg-gray-50"
+          ].join(" "),
+          children: [
+            /* @__PURE__ */ p.jsx(
+              "input",
+              {
+                type: "radio",
+                name: "subscription",
+                value: s.value,
+                checked: n,
+                onChange: () => r(s.value),
+                className: "sr-only"
+              }
+            ),
+            /* @__PURE__ */ p.jsx(
+              "span",
+              {
+                className: [
+                  "flex-shrink-0 flex items-center justify-center rounded-full mr-3",
+                  n ? "w-5 h-5 border-2 border-green-500 bg-green-500" : "w-4 h-4 border border-gray-400"
+                ].join(" "),
+                children: n && /* @__PURE__ */ p.jsx("span", { className: "block w-2 h-2 bg-white rounded-full" })
+              }
+            ),
+            /* @__PURE__ */ p.jsx(
+              "span",
+              {
+                className: n ? "text-green-700 font-medium" : "text-gray-700",
+                children: s.label
+              }
+            )
+          ]
+        },
+        s.value
+      );
+    })
+  }
+), ya = () => {
+  const t = nr(), e = mt((a) => a.nextStep), [r, s] = Qt("300"), n = [
+    { value: "100", label: "100 đơn/tháng" },
+    { value: "300", label: "300 đơn/tháng" },
+    { value: "500", label: "500 đơn/tháng" }
+  ];
+  return /* @__PURE__ */ p.jsxs("div", { className: "w-full flex flex-col gap-6", children: [
+    /* @__PURE__ */ p.jsx("h2", { className: "heading", children: "Select subscription package" }),
+    /* @__PURE__ */ p.jsx(
+      pa,
+      {
+        options: n,
+        value: r,
+        onChange: s
+      }
+    ),
+    /* @__PURE__ */ p.jsx("div", { className: "text-right", children: /* @__PURE__ */ p.jsx(
+      Bt,
+      {
+        title: "Next",
+        isDisabled: !r,
+        handleClick: () => {
+          e(), t("/status");
+        }
+      }
+    ) })
+  ] });
+}, ga = ({ checked: t, setChecked: e }) => /* @__PURE__ */ p.jsxs("label", { className: "relative inline-flex cursor-pointer items-center", children: [
+  /* @__PURE__ */ p.jsx(
+    "input",
+    {
+      type: "checkbox",
+      className: "peer sr-only",
+      checked: t,
+      onChange: (r) => e(r.target.checked)
+    }
+  ),
+  /* @__PURE__ */ p.jsx("div", { className: "border-[#ACADAE] relative h-5 w-5 rounded-full border-2 before:absolute before:left-1/2 before:top-1/2 before:hidden before:h-2.5 before:w-2.5 before:-translate-x-1/2 before:-translate-y-1/2 before:rounded-full before:bg-green-500 peer-checked:border-green-500 peer-checked:before:block" })
+] }), va = [
+  { name: "M-Invoice", route: "m-invoice" },
+  { name: "FPT", route: "fpt" },
+  { name: "Misa", route: "misa" }
+], _a = ({ provider: t, handleProviderChange: e }) => {
+  const r = Et((s) => s.selectedProvider);
+  return /* @__PURE__ */ p.jsxs(
+    "div",
+    {
+      "data-checked": r === t.route,
+      className: `flex items-center justify-center gap-2 px-4 py-2 border border-gray-300 rounded-md hover:bg-gray-100 cursor-pointer\r
+    transition-colors duration-200 data-[checked=true]:border-green-500 data-[checked=true]:text-green-700\r
+    `,
+      onClick: () => e(t.route),
+      children: [
+        /* @__PURE__ */ p.jsx(
+          ga,
+          {
+            checked: r === t.route,
+            setChecked: () => e(t.route)
+          }
+        ),
+        /* @__PURE__ */ p.jsx("label", { className: "", children: t.name })
+      ]
+    }
+  );
+}, ba = () => {
+  const t = nr(), e = Et((a) => a.selectedProvider), r = Et((a) => a.setSelectedProvider), s = mt((a) => a.nextStep), n = (a) => {
+    r(a);
+  };
+  return /* @__PURE__ */ p.jsxs("div", { className: "w-full flex flex-col gap-6", children: [
+    /* @__PURE__ */ p.jsx("h2", { className: "heading", children: "Select Provider" }),
+    /* @__PURE__ */ p.jsx("div", { className: "flex gap-20", children: va.map((a) => /* @__PURE__ */ p.jsx(_a, { provider: a, handleProviderChange: n }, a.route)) }),
+    /* @__PURE__ */ p.jsx("div", { className: "text-right", children: /* @__PURE__ */ p.jsx(
+      Bt,
+      {
+        title: "Next",
+        isDisabled: !e,
+        handleClick: () => {
+          s(), t("/register");
+        }
+      }
+    ) })
+  ] });
+}, xa = () => /* @__PURE__ */ p.jsx("div", { children: "Status" });
+function Sa() {
+  return /* @__PURE__ */ p.jsx(xs, { children: /* @__PURE__ */ p.jsx(ks, { children: /* @__PURE__ */ p.jsxs(We, { element: /* @__PURE__ */ p.jsx(Os, {}), children: [
+    /* @__PURE__ */ p.jsx(We, { index: !0, element: /* @__PURE__ */ p.jsx(ws, { to: "/select-provider", replace: !0 }) }),
+    /* @__PURE__ */ p.jsx(We, { path: "select-provider", element: /* @__PURE__ */ p.jsx(ba, {}) }),
+    /* @__PURE__ */ p.jsx(We, { path: "register", element: /* @__PURE__ */ p.jsx(ma, {}) }),
+    /* @__PURE__ */ p.jsx(We, { path: "select-plan", element: /* @__PURE__ */ p.jsx(ya, {}) }),
+    /* @__PURE__ */ p.jsx(We, { path: "status", element: /* @__PURE__ */ p.jsx(xa, {}) }),
+    /* @__PURE__ */ p.jsx(
+      We,
+      {
+        path: "*",
+        element: /* @__PURE__ */ p.jsx("div", { className: "text-center text-red-500", children: "404: Page Not Found" })
+      }
+    )
+  ] }) }) });
+}
+export {
+  Sa as default
+};