@getopenpay/openpay-js-react 0.0.1-alpha.09717a2

package/dist/index.js

@@ -0,0 +1,3685 @@
+import Yr, { createContext as qr, useContext as Jr, useState as Ce, useRef as sr, useEffect as Et, useCallback as ir, useMemo as xt } from "react";
+const or = qr({
+  contextId: "",
+  createToken: () => {
+  },
+  dispatchEvent: () => {
+  },
+  formHeight: ""
+}), Hr = () => {
+  const r = Jr(or);
+  if (!r)
+    throw new Error("useOpenPayElements must be used within an OpenPayElementsProvider");
+  return r;
+};
+var Tt = { exports: {} }, Ke = {};
+/**
+ * @license React
+ * react-jsx-dev-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var er;
+function Gr() {
+  if (er) return Ke;
+  er = 1;
+  var r = Symbol.for("react.fragment");
+  return Ke.Fragment = r, Ke.jsxDEV = void 0, Ke;
+}
+var Xe = {};
+/**
+ * @license React
+ * react-jsx-dev-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var tr;
+function Kr() {
+  return tr || (tr = 1, process.env.NODE_ENV !== "production" && function() {
+    var r = Yr, e = Symbol.for("react.element"), t = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), a = Symbol.for("react.strict_mode"), s = Symbol.for("react.profiler"), o = Symbol.for("react.provider"), c = Symbol.for("react.context"), f = Symbol.for("react.forward_ref"), l = Symbol.for("react.suspense"), y = Symbol.for("react.suspense_list"), j = Symbol.for("react.memo"), z = Symbol.for("react.lazy"), P = Symbol.for("react.offscreen"), Ye = Symbol.iterator, he = "@@iterator";
+    function dt(i) {
+      if (i === null || typeof i != "object")
+        return null;
+      var u = Ye && i[Ye] || i[he];
+      return typeof u == "function" ? u : null;
+    }
+    var Q = r.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function N(i) {
+      {
+        for (var u = arguments.length, p = new Array(u > 1 ? u - 1 : 0), b = 1; b < u; b++)
+          p[b - 1] = arguments[b];
+        Ee("error", i, p);
+      }
+    }
+    function Ee(i, u, p) {
+      {
+        var b = Q.ReactDebugCurrentFrame, R = b.getStackAddendum();
+        R !== "" && (u += "%s", p = p.concat([R]));
+        var S = p.map(function(E) {
+          return String(E);
+        });
+        S.unshift("Warning: " + u), Function.prototype.apply.call(console[i], console, S);
+      }
+    }
+    var C = !1, ee = !1, pe = !1, lt = !1, gr = !1, Nt;
+    Nt = Symbol.for("react.module.reference");
+    function _r(i) {
+      return !!(typeof i == "string" || typeof i == "function" || i === n || i === s || gr || i === a || i === l || i === y || lt || i === P || C || ee || pe || typeof i == "object" && i !== null && (i.$$typeof === z || i.$$typeof === j || i.$$typeof === o || i.$$typeof === c || i.$$typeof === f || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      i.$$typeof === Nt || i.getModuleId !== void 0));
+    }
+    function br(i, u, p) {
+      var b = i.displayName;
+      if (b)
+        return b;
+      var R = u.displayName || u.name || "";
+      return R !== "" ? p + "(" + R + ")" : p;
+    }
+    function It(i) {
+      return i.displayName || "Context";
+    }
+    function q(i) {
+      if (i == null)
+        return null;
+      if (typeof i.tag == "number" && N("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof i == "function")
+        return i.displayName || i.name || null;
+      if (typeof i == "string")
+        return i;
+      switch (i) {
+        case n:
+          return "Fragment";
+        case t:
+          return "Portal";
+        case s:
+          return "Profiler";
+        case a:
+          return "StrictMode";
+        case l:
+          return "Suspense";
+        case y:
+          return "SuspenseList";
+      }
+      if (typeof i == "object")
+        switch (i.$$typeof) {
+          case c:
+            var u = i;
+            return It(u) + ".Consumer";
+          case o:
+            var p = i;
+            return It(p._context) + ".Provider";
+          case f:
+            return br(i, i.render, "ForwardRef");
+          case j:
+            var b = i.displayName || null;
+            return b !== null ? b : q(i.type) || "Memo";
+          case z: {
+            var R = i, S = R._payload, E = R._init;
+            try {
+              return q(E(S));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var oe = Object.assign, Te = 0, Zt, Pt, At, Dt, $t, Vt, Mt;
+    function Lt() {
+    }
+    Lt.__reactDisabledLog = !0;
+    function xr() {
+      {
+        if (Te === 0) {
+          Zt = console.log, Pt = console.info, At = console.warn, Dt = console.error, $t = console.group, Vt = console.groupCollapsed, Mt = console.groupEnd;
+          var i = {
+            configurable: !0,
+            enumerable: !0,
+            value: Lt,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: i,
+            log: i,
+            warn: i,
+            error: i,
+            group: i,
+            groupCollapsed: i,
+            groupEnd: i
+          });
+        }
+        Te++;
+      }
+    }
+    function kr() {
+      {
+        if (Te--, Te === 0) {
+          var i = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: oe({}, i, {
+              value: Zt
+            }),
+            info: oe({}, i, {
+              value: Pt
+            }),
+            warn: oe({}, i, {
+              value: At
+            }),
+            error: oe({}, i, {
+              value: Dt
+            }),
+            group: oe({}, i, {
+              value: $t
+            }),
+            groupCollapsed: oe({}, i, {
+              value: Vt
+            }),
+            groupEnd: oe({}, i, {
+              value: Mt
+            })
+          });
+        }
+        Te < 0 && N("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ft = Q.ReactCurrentDispatcher, ht;
+    function qe(i, u, p) {
+      {
+        if (ht === void 0)
+          try {
+            throw Error();
+          } catch (R) {
+            var b = R.stack.trim().match(/\n( *(at )?)/);
+            ht = b && b[1] || "";
+          }
+        return `
+` + ht + i;
+      }
+    }
+    var pt = !1, Je;
+    {
+      var wr = typeof WeakMap == "function" ? WeakMap : Map;
+      Je = new wr();
+    }
+    function Ut(i, u) {
+      if (!i || pt)
+        return "";
+      {
+        var p = Je.get(i);
+        if (p !== void 0)
+          return p;
+      }
+      var b;
+      pt = !0;
+      var R = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var S;
+      S = ft.current, ft.current = null, xr();
+      try {
+        if (u) {
+          var E = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(E.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(E, []);
+            } catch (L) {
+              b = L;
+            }
+            Reflect.construct(i, [], E);
+          } else {
+            try {
+              E.call();
+            } catch (L) {
+              b = L;
+            }
+            i.call(E.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (L) {
+            b = L;
+          }
+          i();
+        }
+      } catch (L) {
+        if (L && b && typeof L.stack == "string") {
+          for (var w = L.stack.split(`
+`), $ = b.stack.split(`
+`), I = w.length - 1, Z = $.length - 1; I >= 1 && Z >= 0 && w[I] !== $[Z]; )
+            Z--;
+          for (; I >= 1 && Z >= 0; I--, Z--)
+            if (w[I] !== $[Z]) {
+              if (I !== 1 || Z !== 1)
+                do
+                  if (I--, Z--, Z < 0 || w[I] !== $[Z]) {
+                    var W = `
+` + w[I].replace(" at new ", " at ");
+                    return i.displayName && W.includes("<anonymous>") && (W = W.replace("<anonymous>", i.displayName)), typeof i == "function" && Je.set(i, W), W;
+                  }
+                while (I >= 1 && Z >= 0);
+              break;
+            }
+        }
+      } finally {
+        pt = !1, ft.current = S, kr(), Error.prepareStackTrace = R;
+      }
+      var ve = i ? i.displayName || i.name : "", ce = ve ? qe(ve) : "";
+      return typeof i == "function" && Je.set(i, ce), ce;
+    }
+    function Er(i, u, p) {
+      return Ut(i, !1);
+    }
+    function Tr(i) {
+      var u = i.prototype;
+      return !!(u && u.isReactComponent);
+    }
+    function He(i, u, p) {
+      if (i == null)
+        return "";
+      if (typeof i == "function")
+        return Ut(i, Tr(i));
+      if (typeof i == "string")
+        return qe(i);
+      switch (i) {
+        case l:
+          return qe("Suspense");
+        case y:
+          return qe("SuspenseList");
+      }
+      if (typeof i == "object")
+        switch (i.$$typeof) {
+          case f:
+            return Er(i.render);
+          case j:
+            return He(i.type, u, p);
+          case z: {
+            var b = i, R = b._payload, S = b._init;
+            try {
+              return He(S(R), u, p);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var Re = Object.prototype.hasOwnProperty, zt = {}, Wt = Q.ReactDebugCurrentFrame;
+    function Ge(i) {
+      if (i) {
+        var u = i._owner, p = He(i.type, i._source, u ? u.type : null);
+        Wt.setExtraStackFrame(p);
+      } else
+        Wt.setExtraStackFrame(null);
+    }
+    function Rr(i, u, p, b, R) {
+      {
+        var S = Function.call.bind(Re);
+        for (var E in i)
+          if (S(i, E)) {
+            var w = void 0;
+            try {
+              if (typeof i[E] != "function") {
+                var $ = Error((b || "React class") + ": " + p + " type `" + E + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof i[E] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw $.name = "Invariant Violation", $;
+              }
+              w = i[E](u, E, b, p, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (I) {
+              w = I;
+            }
+            w && !(w instanceof Error) && (Ge(R), N("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", b || "React class", p, E, typeof w), Ge(null)), w instanceof Error && !(w.message in zt) && (zt[w.message] = !0, Ge(R), N("Failed %s type: %s", p, w.message), Ge(null));
+          }
+      }
+    }
+    var Sr = Array.isArray;
+    function mt(i) {
+      return Sr(i);
+    }
+    function Cr(i) {
+      {
+        var u = typeof Symbol == "function" && Symbol.toStringTag, p = u && i[Symbol.toStringTag] || i.constructor.name || "Object";
+        return p;
+      }
+    }
+    function Or(i) {
+      try {
+        return Bt(i), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Bt(i) {
+      return "" + i;
+    }
+    function Ft(i) {
+      if (Or(i))
+        return N("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Cr(i)), Bt(i);
+    }
+    var Se = Q.ReactCurrentOwner, jr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Yt, qt, vt;
+    vt = {};
+    function Nr(i) {
+      if (Re.call(i, "ref")) {
+        var u = Object.getOwnPropertyDescriptor(i, "ref").get;
+        if (u && u.isReactWarning)
+          return !1;
+      }
+      return i.ref !== void 0;
+    }
+    function Ir(i) {
+      if (Re.call(i, "key")) {
+        var u = Object.getOwnPropertyDescriptor(i, "key").get;
+        if (u && u.isReactWarning)
+          return !1;
+      }
+      return i.key !== void 0;
+    }
+    function Zr(i, u) {
+      if (typeof i.ref == "string" && Se.current && u && Se.current.stateNode !== u) {
+        var p = q(Se.current.type);
+        vt[p] || (N('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', q(Se.current.type), i.ref), vt[p] = !0);
+      }
+    }
+    function Pr(i, u) {
+      {
+        var p = function() {
+          Yt || (Yt = !0, N("%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://reactjs.org/link/special-props)", u));
+        };
+        p.isReactWarning = !0, Object.defineProperty(i, "key", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    function Ar(i, u) {
+      {
+        var p = function() {
+          qt || (qt = !0, N("%s: `ref` 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://reactjs.org/link/special-props)", u));
+        };
+        p.isReactWarning = !0, Object.defineProperty(i, "ref", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    var Dr = function(i, u, p, b, R, S, E) {
+      var w = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: e,
+        // Built-in properties that belong on the element
+        type: i,
+        key: u,
+        ref: p,
+        props: E,
+        // Record the component responsible for creating this element.
+        _owner: S
+      };
+      return w._store = {}, Object.defineProperty(w._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(w, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: b
+      }), Object.defineProperty(w, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: R
+      }), Object.freeze && (Object.freeze(w.props), Object.freeze(w)), w;
+    };
+    function $r(i, u, p, b, R) {
+      {
+        var S, E = {}, w = null, $ = null;
+        p !== void 0 && (Ft(p), w = "" + p), Ir(u) && (Ft(u.key), w = "" + u.key), Nr(u) && ($ = u.ref, Zr(u, R));
+        for (S in u)
+          Re.call(u, S) && !jr.hasOwnProperty(S) && (E[S] = u[S]);
+        if (i && i.defaultProps) {
+          var I = i.defaultProps;
+          for (S in I)
+            E[S] === void 0 && (E[S] = I[S]);
+        }
+        if (w || $) {
+          var Z = typeof i == "function" ? i.displayName || i.name || "Unknown" : i;
+          w && Pr(E, Z), $ && Ar(E, Z);
+        }
+        return Dr(i, w, $, R, b, Se.current, E);
+      }
+    }
+    var yt = Q.ReactCurrentOwner, Jt = Q.ReactDebugCurrentFrame;
+    function me(i) {
+      if (i) {
+        var u = i._owner, p = He(i.type, i._source, u ? u.type : null);
+        Jt.setExtraStackFrame(p);
+      } else
+        Jt.setExtraStackFrame(null);
+    }
+    var gt;
+    gt = !1;
+    function _t(i) {
+      return typeof i == "object" && i !== null && i.$$typeof === e;
+    }
+    function Ht() {
+      {
+        if (yt.current) {
+          var i = q(yt.current.type);
+          if (i)
+            return `
+
+Check the render method of \`` + i + "`.";
+        }
+        return "";
+      }
+    }
+    function Vr(i) {
+      {
+        if (i !== void 0) {
+          var u = i.fileName.replace(/^.*[\\\/]/, ""), p = i.lineNumber;
+          return `
+
+Check your code at ` + u + ":" + p + ".";
+        }
+        return "";
+      }
+    }
+    var Gt = {};
+    function Mr(i) {
+      {
+        var u = Ht();
+        if (!u) {
+          var p = typeof i == "string" ? i : i.displayName || i.name;
+          p && (u = `
+
+Check the top-level render call using <` + p + ">.");
+        }
+        return u;
+      }
+    }
+    function Kt(i, u) {
+      {
+        if (!i._store || i._store.validated || i.key != null)
+          return;
+        i._store.validated = !0;
+        var p = Mr(u);
+        if (Gt[p])
+          return;
+        Gt[p] = !0;
+        var b = "";
+        i && i._owner && i._owner !== yt.current && (b = " It was passed a child from " + q(i._owner.type) + "."), me(i), N('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', p, b), me(null);
+      }
+    }
+    function Xt(i, u) {
+      {
+        if (typeof i != "object")
+          return;
+        if (mt(i))
+          for (var p = 0; p < i.length; p++) {
+            var b = i[p];
+            _t(b) && Kt(b, u);
+          }
+        else if (_t(i))
+          i._store && (i._store.validated = !0);
+        else if (i) {
+          var R = dt(i);
+          if (typeof R == "function" && R !== i.entries)
+            for (var S = R.call(i), E; !(E = S.next()).done; )
+              _t(E.value) && Kt(E.value, u);
+        }
+      }
+    }
+    function Lr(i) {
+      {
+        var u = i.type;
+        if (u == null || typeof u == "string")
+          return;
+        var p;
+        if (typeof u == "function")
+          p = u.propTypes;
+        else if (typeof u == "object" && (u.$$typeof === f || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        u.$$typeof === j))
+          p = u.propTypes;
+        else
+          return;
+        if (p) {
+          var b = q(u);
+          Rr(p, i.props, "prop", b, i);
+        } else if (u.PropTypes !== void 0 && !gt) {
+          gt = !0;
+          var R = q(u);
+          N("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", R || "Unknown");
+        }
+        typeof u.getDefaultProps == "function" && !u.getDefaultProps.isReactClassApproved && N("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Ur(i) {
+      {
+        for (var u = Object.keys(i.props), p = 0; p < u.length; p++) {
+          var b = u[p];
+          if (b !== "children" && b !== "key") {
+            me(i), N("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", b), me(null);
+            break;
+          }
+        }
+        i.ref !== null && (me(i), N("Invalid attribute `ref` supplied to `React.Fragment`."), me(null));
+      }
+    }
+    var Qt = {};
+    function zr(i, u, p, b, R, S) {
+      {
+        var E = _r(i);
+        if (!E) {
+          var w = "";
+          (i === void 0 || typeof i == "object" && i !== null && Object.keys(i).length === 0) && (w += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var $ = Vr(R);
+          $ ? w += $ : w += Ht();
+          var I;
+          i === null ? I = "null" : mt(i) ? I = "array" : i !== void 0 && i.$$typeof === e ? (I = "<" + (q(i.type) || "Unknown") + " />", w = " Did you accidentally export a JSX literal instead of a component?") : I = typeof i, N("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", I, w);
+        }
+        var Z = $r(i, u, p, R, S);
+        if (Z == null)
+          return Z;
+        if (E) {
+          var W = u.children;
+          if (W !== void 0)
+            if (b)
+              if (mt(W)) {
+                for (var ve = 0; ve < W.length; ve++)
+                  Xt(W[ve], i);
+                Object.freeze && Object.freeze(W);
+              } else
+                N("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
+              Xt(W, i);
+        }
+        if (Re.call(u, "key")) {
+          var ce = q(i), L = Object.keys(u).filter(function(Fr) {
+            return Fr !== "key";
+          }), bt = L.length > 0 ? "{key: someKey, " + L.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Qt[ce + bt]) {
+            var Br = L.length > 0 ? "{" + L.join(": ..., ") + ": ...}" : "{}";
+            N(`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} />`, bt, ce, Br, ce), Qt[ce + bt] = !0;
+          }
+        }
+        return i === n ? Ur(Z) : Lr(Z), Z;
+      }
+    }
+    var Wr = zr;
+    Xe.Fragment = n, Xe.jsxDEV = Wr;
+  }()), Xe;
+}
+process.env.NODE_ENV === "production" ? Tt.exports = Gr() : Tt.exports = Kr();
+var de = Tt.exports, T;
+(function(r) {
+  r.assertEqual = (a) => a;
+  function e(a) {
+  }
+  r.assertIs = e;
+  function t(a) {
+    throw new Error();
+  }
+  r.assertNever = t, r.arrayToEnum = (a) => {
+    const s = {};
+    for (const o of a)
+      s[o] = o;
+    return s;
+  }, r.getValidEnumValues = (a) => {
+    const s = r.objectKeys(a).filter((c) => typeof a[a[c]] != "number"), o = {};
+    for (const c of s)
+      o[c] = a[c];
+    return r.objectValues(o);
+  }, r.objectValues = (a) => r.objectKeys(a).map(function(s) {
+    return a[s];
+  }), r.objectKeys = typeof Object.keys == "function" ? (a) => Object.keys(a) : (a) => {
+    const s = [];
+    for (const o in a)
+      Object.prototype.hasOwnProperty.call(a, o) && s.push(o);
+    return s;
+  }, r.find = (a, s) => {
+    for (const o of a)
+      if (s(o))
+        return o;
+  }, r.isInteger = typeof Number.isInteger == "function" ? (a) => Number.isInteger(a) : (a) => typeof a == "number" && isFinite(a) && Math.floor(a) === a;
+  function n(a, s = " | ") {
+    return a.map((o) => typeof o == "string" ? `'${o}'` : o).join(s);
+  }
+  r.joinValues = n, r.jsonStringifyReplacer = (a, s) => typeof s == "bigint" ? s.toString() : s;
+})(T || (T = {}));
+var Rt;
+(function(r) {
+  r.mergeShapes = (e, t) => ({
+    ...e,
+    ...t
+    // second overwrites first
+  });
+})(Rt || (Rt = {}));
+const m = T.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]), re = (r) => {
+  switch (typeof r) {
+    case "undefined":
+      return m.undefined;
+    case "string":
+      return m.string;
+    case "number":
+      return isNaN(r) ? m.nan : m.number;
+    case "boolean":
+      return m.boolean;
+    case "function":
+      return m.function;
+    case "bigint":
+      return m.bigint;
+    case "symbol":
+      return m.symbol;
+    case "object":
+      return Array.isArray(r) ? m.array : r === null ? m.null : r.then && typeof r.then == "function" && r.catch && typeof r.catch == "function" ? m.promise : typeof Map < "u" && r instanceof Map ? m.map : typeof Set < "u" && r instanceof Set ? m.set : typeof Date < "u" && r instanceof Date ? m.date : m.object;
+    default:
+      return m.unknown;
+  }
+}, d = T.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"
+]), Xr = (r) => JSON.stringify(r, null, 2).replace(/"([^"]+)":/g, "$1:");
+class U extends Error {
+  constructor(e) {
+    super(), this.issues = [], this.addIssue = (n) => {
+      this.issues = [...this.issues, n];
+    }, this.addIssues = (n = []) => {
+      this.issues = [...this.issues, ...n];
+    };
+    const t = new.target.prototype;
+    Object.setPrototypeOf ? Object.setPrototypeOf(this, t) : this.__proto__ = t, this.name = "ZodError", this.issues = e;
+  }
+  get errors() {
+    return this.issues;
+  }
+  format(e) {
+    const t = e || function(s) {
+      return s.message;
+    }, n = { _errors: [] }, a = (s) => {
+      for (const o of s.issues)
+        if (o.code === "invalid_union")
+          o.unionErrors.map(a);
+        else if (o.code === "invalid_return_type")
+          a(o.returnTypeError);
+        else if (o.code === "invalid_arguments")
+          a(o.argumentsError);
+        else if (o.path.length === 0)
+          n._errors.push(t(o));
+        else {
+          let c = n, f = 0;
+          for (; f < o.path.length; ) {
+            const l = o.path[f];
+            f === o.path.length - 1 ? (c[l] = c[l] || { _errors: [] }, c[l]._errors.push(t(o))) : c[l] = c[l] || { _errors: [] }, c = c[l], f++;
+          }
+        }
+    };
+    return a(this), n;
+  }
+  static assert(e) {
+    if (!(e instanceof U))
+      throw new Error(`Not a ZodError: ${e}`);
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, T.jsonStringifyReplacer, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(e = (t) => t.message) {
+    const t = {}, n = [];
+    for (const a of this.issues)
+      a.path.length > 0 ? (t[a.path[0]] = t[a.path[0]] || [], t[a.path[0]].push(e(a))) : n.push(e(a));
+    return { formErrors: n, fieldErrors: t };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+}
+U.create = (r) => new U(r);
+const xe = (r, e) => {
+  let t;
+  switch (r.code) {
+    case d.invalid_type:
+      r.received === m.undefined ? t = "Required" : t = `Expected ${r.expected}, received ${r.received}`;
+      break;
+    case d.invalid_literal:
+      t = `Invalid literal value, expected ${JSON.stringify(r.expected, T.jsonStringifyReplacer)}`;
+      break;
+    case d.unrecognized_keys:
+      t = `Unrecognized key(s) in object: ${T.joinValues(r.keys, ", ")}`;
+      break;
+    case d.invalid_union:
+      t = "Invalid input";
+      break;
+    case d.invalid_union_discriminator:
+      t = `Invalid discriminator value. Expected ${T.joinValues(r.options)}`;
+      break;
+    case d.invalid_enum_value:
+      t = `Invalid enum value. Expected ${T.joinValues(r.options)}, received '${r.received}'`;
+      break;
+    case d.invalid_arguments:
+      t = "Invalid function arguments";
+      break;
+    case d.invalid_return_type:
+      t = "Invalid function return type";
+      break;
+    case d.invalid_date:
+      t = "Invalid date";
+      break;
+    case d.invalid_string:
+      typeof r.validation == "object" ? "includes" in r.validation ? (t = `Invalid input: must include "${r.validation.includes}"`, typeof r.validation.position == "number" && (t = `${t} at one or more positions greater than or equal to ${r.validation.position}`)) : "startsWith" in r.validation ? t = `Invalid input: must start with "${r.validation.startsWith}"` : "endsWith" in r.validation ? t = `Invalid input: must end with "${r.validation.endsWith}"` : T.assertNever(r.validation) : r.validation !== "regex" ? t = `Invalid ${r.validation}` : t = "Invalid";
+      break;
+    case d.too_small:
+      r.type === "array" ? t = `Array must contain ${r.exact ? "exactly" : r.inclusive ? "at least" : "more than"} ${r.minimum} element(s)` : r.type === "string" ? t = `String must contain ${r.exact ? "exactly" : r.inclusive ? "at least" : "over"} ${r.minimum} character(s)` : r.type === "number" ? t = `Number must be ${r.exact ? "exactly equal to " : r.inclusive ? "greater than or equal to " : "greater than "}${r.minimum}` : r.type === "date" ? t = `Date must be ${r.exact ? "exactly equal to " : r.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(r.minimum))}` : t = "Invalid input";
+      break;
+    case d.too_big:
+      r.type === "array" ? t = `Array must contain ${r.exact ? "exactly" : r.inclusive ? "at most" : "less than"} ${r.maximum} element(s)` : r.type === "string" ? t = `String must contain ${r.exact ? "exactly" : r.inclusive ? "at most" : "under"} ${r.maximum} character(s)` : r.type === "number" ? t = `Number must be ${r.exact ? "exactly" : r.inclusive ? "less than or equal to" : "less than"} ${r.maximum}` : r.type === "bigint" ? t = `BigInt must be ${r.exact ? "exactly" : r.inclusive ? "less than or equal to" : "less than"} ${r.maximum}` : r.type === "date" ? t = `Date must be ${r.exact ? "exactly" : r.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(r.maximum))}` : t = "Invalid input";
+      break;
+    case d.custom:
+      t = "Invalid input";
+      break;
+    case d.invalid_intersection_types:
+      t = "Intersection results could not be merged";
+      break;
+    case d.not_multiple_of:
+      t = `Number must be a multiple of ${r.multipleOf}`;
+      break;
+    case d.not_finite:
+      t = "Number must be finite";
+      break;
+    default:
+      t = e.defaultError, T.assertNever(r);
+  }
+  return { message: t };
+};
+let cr = xe;
+function Qr(r) {
+  cr = r;
+}
+function tt() {
+  return cr;
+}
+const rt = (r) => {
+  const { data: e, path: t, errorMaps: n, issueData: a } = r, s = [...t, ...a.path || []], o = {
+    ...a,
+    path: s
+  };
+  if (a.message !== void 0)
+    return {
+      ...a,
+      path: s,
+      message: a.message
+    };
+  let c = "";
+  const f = n.filter((l) => !!l).slice().reverse();
+  for (const l of f)
+    c = l(o, { data: e, defaultError: c }).message;
+  return {
+    ...a,
+    path: s,
+    message: c
+  };
+}, en = [];
+function h(r, e) {
+  const t = tt(), n = rt({
+    issueData: e,
+    data: r.data,
+    path: r.path,
+    errorMaps: [
+      r.common.contextualErrorMap,
+      r.schemaErrorMap,
+      t,
+      t === xe ? void 0 : xe
+      // then global default map
+    ].filter((a) => !!a)
+  });
+  r.common.issues.push(n);
+}
+class D {
+  constructor() {
+    this.value = "valid";
+  }
+  dirty() {
+    this.value === "valid" && (this.value = "dirty");
+  }
+  abort() {
+    this.value !== "aborted" && (this.value = "aborted");
+  }
+  static mergeArray(e, t) {
+    const n = [];
+    for (const a of t) {
+      if (a.status === "aborted")
+        return _;
+      a.status === "dirty" && e.dirty(), n.push(a.value);
+    }
+    return { status: e.value, value: n };
+  }
+  static async mergeObjectAsync(e, t) {
+    const n = [];
+    for (const a of t) {
+      const s = await a.key, o = await a.value;
+      n.push({
+        key: s,
+        value: o
+      });
+    }
+    return D.mergeObjectSync(e, n);
+  }
+  static mergeObjectSync(e, t) {
+    const n = {};
+    for (const a of t) {
+      const { key: s, value: o } = a;
+      if (s.status === "aborted" || o.status === "aborted")
+        return _;
+      s.status === "dirty" && e.dirty(), o.status === "dirty" && e.dirty(), s.value !== "__proto__" && (typeof o.value < "u" || a.alwaysSet) && (n[s.value] = o.value);
+    }
+    return { status: e.value, value: n };
+  }
+}
+const _ = Object.freeze({
+  status: "aborted"
+}), _e = (r) => ({ status: "dirty", value: r }), M = (r) => ({ status: "valid", value: r }), St = (r) => r.status === "aborted", Ct = (r) => r.status === "dirty", Ne = (r) => r.status === "valid", Ie = (r) => typeof Promise < "u" && r instanceof Promise;
+function nt(r, e, t, n) {
+  if (typeof e == "function" ? r !== e || !n : !e.has(r)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return e.get(r);
+}
+function ur(r, e, t, n, a) {
+  if (typeof e == "function" ? r !== e || !a : !e.has(r)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return e.set(r, t), t;
+}
+var v;
+(function(r) {
+  r.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, r.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message;
+})(v || (v = {}));
+var Oe, je;
+class H {
+  constructor(e, t, n, a) {
+    this._cachedPath = [], this.parent = e, this.data = t, this._path = n, this._key = a;
+  }
+  get path() {
+    return this._cachedPath.length || (this._key instanceof Array ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath;
+  }
+}
+const rr = (r, e) => {
+  if (Ne(e))
+    return { success: !0, data: e.value };
+  if (!r.common.issues.length)
+    throw new Error("Validation failed but no issues detected.");
+  return {
+    success: !1,
+    get error() {
+      if (this._error)
+        return this._error;
+      const t = new U(r.common.issues);
+      return this._error = t, this._error;
+    }
+  };
+};
+function x(r) {
+  if (!r)
+    return {};
+  const { errorMap: e, invalid_type_error: t, required_error: n, description: a } = r;
+  if (e && (t || n))
+    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+  return e ? { errorMap: e, description: a } : { errorMap: (o, c) => {
+    var f, l;
+    const { message: y } = r;
+    return o.code === "invalid_enum_value" ? { message: y ?? c.defaultError } : typeof c.data > "u" ? { message: (f = y ?? n) !== null && f !== void 0 ? f : c.defaultError } : o.code !== "invalid_type" ? { message: c.defaultError } : { message: (l = y ?? t) !== null && l !== void 0 ? l : c.defaultError };
+  }, description: a };
+}
+class k {
+  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);
+  }
+  get description() {
+    return this._def.description;
+  }
+  _getType(e) {
+    return re(e.data);
+  }
+  _getOrReturnCtx(e, t) {
+    return t || {
+      common: e.parent.common,
+      data: e.data,
+      parsedType: re(e.data),
+      schemaErrorMap: this._def.errorMap,
+      path: e.path,
+      parent: e.parent
+    };
+  }
+  _processInputParams(e) {
+    return {
+      status: new D(),
+      ctx: {
+        common: e.parent.common,
+        data: e.data,
+        parsedType: re(e.data),
+        schemaErrorMap: this._def.errorMap,
+        path: e.path,
+        parent: e.parent
+      }
+    };
+  }
+  _parseSync(e) {
+    const t = this._parse(e);
+    if (Ie(t))
+      throw new Error("Synchronous parse encountered promise.");
+    return t;
+  }
+  _parseAsync(e) {
+    const t = this._parse(e);
+    return Promise.resolve(t);
+  }
+  parse(e, t) {
+    const n = this.safeParse(e, t);
+    if (n.success)
+      return n.data;
+    throw n.error;
+  }
+  safeParse(e, t) {
+    var n;
+    const a = {
+      common: {
+        issues: [],
+        async: (n = t == null ? void 0 : t.async) !== null && n !== void 0 ? n : !1,
+        contextualErrorMap: t == null ? void 0 : t.errorMap
+      },
+      path: (t == null ? void 0 : t.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: re(e)
+    }, s = this._parseSync({ data: e, path: a.path, parent: a });
+    return rr(a, s);
+  }
+  async parseAsync(e, t) {
+    const n = await this.safeParseAsync(e, t);
+    if (n.success)
+      return n.data;
+    throw n.error;
+  }
+  async safeParseAsync(e, t) {
+    const n = {
+      common: {
+        issues: [],
+        contextualErrorMap: t == null ? void 0 : t.errorMap,
+        async: !0
+      },
+      path: (t == null ? void 0 : t.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: re(e)
+    }, a = this._parse({ data: e, path: n.path, parent: n }), s = await (Ie(a) ? a : Promise.resolve(a));
+    return rr(n, s);
+  }
+  refine(e, t) {
+    const n = (a) => typeof t == "string" || typeof t > "u" ? { message: t } : typeof t == "function" ? t(a) : t;
+    return this._refinement((a, s) => {
+      const o = e(a), c = () => s.addIssue({
+        code: d.custom,
+        ...n(a)
+      });
+      return typeof Promise < "u" && o instanceof Promise ? o.then((f) => f ? !0 : (c(), !1)) : o ? !0 : (c(), !1);
+    });
+  }
+  refinement(e, t) {
+    return this._refinement((n, a) => e(n) ? !0 : (a.addIssue(typeof t == "function" ? t(n, a) : t), !1));
+  }
+  _refinement(e) {
+    return new Y({
+      schema: this,
+      typeName: g.ZodEffects,
+      effect: { type: "refinement", refinement: e }
+    });
+  }
+  superRefine(e) {
+    return this._refinement(e);
+  }
+  optional() {
+    return J.create(this, this._def);
+  }
+  nullable() {
+    return ie.create(this, this._def);
+  }
+  nullish() {
+    return this.nullable().optional();
+  }
+  array() {
+    return F.create(this, this._def);
+  }
+  promise() {
+    return we.create(this, this._def);
+  }
+  or(e) {
+    return De.create([this, e], this._def);
+  }
+  and(e) {
+    return $e.create(this, e, this._def);
+  }
+  transform(e) {
+    return new Y({
+      ...x(this._def),
+      schema: this,
+      typeName: g.ZodEffects,
+      effect: { type: "transform", transform: e }
+    });
+  }
+  default(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new ze({
+      ...x(this._def),
+      innerType: this,
+      defaultValue: t,
+      typeName: g.ZodDefault
+    });
+  }
+  brand() {
+    return new jt({
+      typeName: g.ZodBranded,
+      type: this,
+      ...x(this._def)
+    });
+  }
+  catch(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new We({
+      ...x(this._def),
+      innerType: this,
+      catchValue: t,
+      typeName: g.ZodCatch
+    });
+  }
+  describe(e) {
+    const t = this.constructor;
+    return new t({
+      ...this._def,
+      description: e
+    });
+  }
+  pipe(e) {
+    return Fe.create(this, e);
+  }
+  readonly() {
+    return Be.create(this);
+  }
+  isOptional() {
+    return this.safeParse(void 0).success;
+  }
+  isNullable() {
+    return this.safeParse(null).success;
+  }
+}
+const tn = /^c[^\s-]{8,}$/i, rn = /^[0-9a-z]+$/, nn = /^[0-9A-HJKMNP-TV-Z]{26}$/, an = /^[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, sn = /^[a-z0-9_-]{21}$/i, on = /^[-+]?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)?)??$/, cn = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, un = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+let kt;
+const dn = /^(?:(?: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])$/, ln = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/, fn = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, dr = "((\\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])))", hn = new RegExp(`^${dr}$`);
+function lr(r) {
+  let e = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d";
+  return r.precision ? e = `${e}\\.\\d{${r.precision}}` : r.precision == null && (e = `${e}(\\.\\d+)?`), e;
+}
+function pn(r) {
+  return new RegExp(`^${lr(r)}$`);
+}
+function fr(r) {
+  let e = `${dr}T${lr(r)}`;
+  const t = [];
+  return t.push(r.local ? "Z?" : "Z"), r.offset && t.push("([+-]\\d{2}:?\\d{2})"), e = `${e}(${t.join("|")})`, new RegExp(`^${e}$`);
+}
+function mn(r, e) {
+  return !!((e === "v4" || !e) && dn.test(r) || (e === "v6" || !e) && ln.test(r));
+}
+class B extends k {
+  _parse(e) {
+    if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== m.string) {
+      const s = this._getOrReturnCtx(e);
+      return h(s, {
+        code: d.invalid_type,
+        expected: m.string,
+        received: s.parsedType
+      }), _;
+    }
+    const n = new D();
+    let a;
+    for (const s of this._def.checks)
+      if (s.kind === "min")
+        e.data.length < s.value && (a = this._getOrReturnCtx(e, a), h(a, {
+          code: d.too_small,
+          minimum: s.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: s.message
+        }), n.dirty());
+      else if (s.kind === "max")
+        e.data.length > s.value && (a = this._getOrReturnCtx(e, a), h(a, {
+          code: d.too_big,
+          maximum: s.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: s.message
+        }), n.dirty());
+      else if (s.kind === "length") {
+        const o = e.data.length > s.value, c = e.data.length < s.value;
+        (o || c) && (a = this._getOrReturnCtx(e, a), o ? h(a, {
+          code: d.too_big,
+          maximum: s.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: s.message
+        }) : c && h(a, {
+          code: d.too_small,
+          minimum: s.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: s.message
+        }), n.dirty());
+      } else if (s.kind === "email")
+        cn.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+          validation: "email",
+          code: d.invalid_string,
+          message: s.message
+        }), n.dirty());
+      else if (s.kind === "emoji")
+        kt || (kt = new RegExp(un, "u")), kt.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+          validation: "emoji",
+          code: d.invalid_string,
+          message: s.message
+        }), n.dirty());
+      else if (s.kind === "uuid")
+        an.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+          validation: "uuid",
+          code: d.invalid_string,
+          message: s.message
+        }), n.dirty());
+      else if (s.kind === "nanoid")
+        sn.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+          validation: "nanoid",
+          code: d.invalid_string,
+          message: s.message
+        }), n.dirty());
+      else if (s.kind === "cuid")
+        tn.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+          validation: "cuid",
+          code: d.invalid_string,
+          message: s.message
+        }), n.dirty());
+      else if (s.kind === "cuid2")
+        rn.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+          validation: "cuid2",
+          code: d.invalid_string,
+          message: s.message
+        }), n.dirty());
+      else if (s.kind === "ulid")
+        nn.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+          validation: "ulid",
+          code: d.invalid_string,
+          message: s.message
+        }), n.dirty());
+      else if (s.kind === "url")
+        try {
+          new URL(e.data);
+        } catch {
+          a = this._getOrReturnCtx(e, a), h(a, {
+            validation: "url",
+            code: d.invalid_string,
+            message: s.message
+          }), n.dirty();
+        }
+      else s.kind === "regex" ? (s.regex.lastIndex = 0, s.regex.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+        validation: "regex",
+        code: d.invalid_string,
+        message: s.message
+      }), n.dirty())) : s.kind === "trim" ? e.data = e.data.trim() : s.kind === "includes" ? e.data.includes(s.value, s.position) || (a = this._getOrReturnCtx(e, a), h(a, {
+        code: d.invalid_string,
+        validation: { includes: s.value, position: s.position },
+        message: s.message
+      }), n.dirty()) : s.kind === "toLowerCase" ? e.data = e.data.toLowerCase() : s.kind === "toUpperCase" ? e.data = e.data.toUpperCase() : s.kind === "startsWith" ? e.data.startsWith(s.value) || (a = this._getOrReturnCtx(e, a), h(a, {
+        code: d.invalid_string,
+        validation: { startsWith: s.value },
+        message: s.message
+      }), n.dirty()) : s.kind === "endsWith" ? e.data.endsWith(s.value) || (a = this._getOrReturnCtx(e, a), h(a, {
+        code: d.invalid_string,
+        validation: { endsWith: s.value },
+        message: s.message
+      }), n.dirty()) : s.kind === "datetime" ? fr(s).test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+        code: d.invalid_string,
+        validation: "datetime",
+        message: s.message
+      }), n.dirty()) : s.kind === "date" ? hn.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+        code: d.invalid_string,
+        validation: "date",
+        message: s.message
+      }), n.dirty()) : s.kind === "time" ? pn(s).test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+        code: d.invalid_string,
+        validation: "time",
+        message: s.message
+      }), n.dirty()) : s.kind === "duration" ? on.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+        validation: "duration",
+        code: d.invalid_string,
+        message: s.message
+      }), n.dirty()) : s.kind === "ip" ? mn(e.data, s.version) || (a = this._getOrReturnCtx(e, a), h(a, {
+        validation: "ip",
+        code: d.invalid_string,
+        message: s.message
+      }), n.dirty()) : s.kind === "base64" ? fn.test(e.data) || (a = this._getOrReturnCtx(e, a), h(a, {
+        validation: "base64",
+        code: d.invalid_string,
+        message: s.message
+      }), n.dirty()) : T.assertNever(s);
+    return { status: n.value, value: e.data };
+  }
+  _regex(e, t, n) {
+    return this.refinement((a) => e.test(a), {
+      validation: t,
+      code: d.invalid_string,
+      ...v.errToObj(n)
+    });
+  }
+  _addCheck(e) {
+    return new B({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  email(e) {
+    return this._addCheck({ kind: "email", ...v.errToObj(e) });
+  }
+  url(e) {
+    return this._addCheck({ kind: "url", ...v.errToObj(e) });
+  }
+  emoji(e) {
+    return this._addCheck({ kind: "emoji", ...v.errToObj(e) });
+  }
+  uuid(e) {
+    return this._addCheck({ kind: "uuid", ...v.errToObj(e) });
+  }
+  nanoid(e) {
+    return this._addCheck({ kind: "nanoid", ...v.errToObj(e) });
+  }
+  cuid(e) {
+    return this._addCheck({ kind: "cuid", ...v.errToObj(e) });
+  }
+  cuid2(e) {
+    return this._addCheck({ kind: "cuid2", ...v.errToObj(e) });
+  }
+  ulid(e) {
+    return this._addCheck({ kind: "ulid", ...v.errToObj(e) });
+  }
+  base64(e) {
+    return this._addCheck({ kind: "base64", ...v.errToObj(e) });
+  }
+  ip(e) {
+    return this._addCheck({ kind: "ip", ...v.errToObj(e) });
+  }
+  datetime(e) {
+    var t, n;
+    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: (t = e == null ? void 0 : e.offset) !== null && t !== void 0 ? t : !1,
+      local: (n = e == null ? void 0 : e.local) !== null && n !== void 0 ? n : !1,
+      ...v.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,
+      ...v.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  duration(e) {
+    return this._addCheck({ kind: "duration", ...v.errToObj(e) });
+  }
+  regex(e, t) {
+    return this._addCheck({
+      kind: "regex",
+      regex: e,
+      ...v.errToObj(t)
+    });
+  }
+  includes(e, t) {
+    return this._addCheck({
+      kind: "includes",
+      value: e,
+      position: t == null ? void 0 : t.position,
+      ...v.errToObj(t == null ? void 0 : t.message)
+    });
+  }
+  startsWith(e, t) {
+    return this._addCheck({
+      kind: "startsWith",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  endsWith(e, t) {
+    return this._addCheck({
+      kind: "endsWith",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  length(e, t) {
+    return this._addCheck({
+      kind: "length",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  /**
+   * @deprecated Use z.string().min(1) instead.
+   * @see {@link ZodString.min}
+   */
+  nonempty(e) {
+    return this.min(1, v.errToObj(e));
+  }
+  trim() {
+    return new B({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "trim" }]
+    });
+  }
+  toLowerCase() {
+    return new B({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toLowerCase" }]
+    });
+  }
+  toUpperCase() {
+    return new B({
+      ...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 isBase64() {
+    return !!this._def.checks.find((e) => e.kind === "base64");
+  }
+  get minLength() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e;
+  }
+  get maxLength() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e;
+  }
+}
+B.create = (r) => {
+  var e;
+  return new B({
+    checks: [],
+    typeName: g.ZodString,
+    coerce: (e = r == null ? void 0 : r.coerce) !== null && e !== void 0 ? e : !1,
+    ...x(r)
+  });
+};
+function vn(r, e) {
+  const t = (r.toString().split(".")[1] || "").length, n = (e.toString().split(".")[1] || "").length, a = t > n ? t : n, s = parseInt(r.toFixed(a).replace(".", "")), o = parseInt(e.toFixed(a).replace(".", ""));
+  return s % o / Math.pow(10, a);
+}
+class ne extends k {
+  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) !== m.number) {
+      const s = this._getOrReturnCtx(e);
+      return h(s, {
+        code: d.invalid_type,
+        expected: m.number,
+        received: s.parsedType
+      }), _;
+    }
+    let n;
+    const a = new D();
+    for (const s of this._def.checks)
+      s.kind === "int" ? T.isInteger(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+        code: d.invalid_type,
+        expected: "integer",
+        received: "float",
+        message: s.message
+      }), a.dirty()) : s.kind === "min" ? (s.inclusive ? e.data < s.value : e.data <= s.value) && (n = this._getOrReturnCtx(e, n), h(n, {
+        code: d.too_small,
+        minimum: s.value,
+        type: "number",
+        inclusive: s.inclusive,
+        exact: !1,
+        message: s.message
+      }), a.dirty()) : s.kind === "max" ? (s.inclusive ? e.data > s.value : e.data >= s.value) && (n = this._getOrReturnCtx(e, n), h(n, {
+        code: d.too_big,
+        maximum: s.value,
+        type: "number",
+        inclusive: s.inclusive,
+        exact: !1,
+        message: s.message
+      }), a.dirty()) : s.kind === "multipleOf" ? vn(e.data, s.value) !== 0 && (n = this._getOrReturnCtx(e, n), h(n, {
+        code: d.not_multiple_of,
+        multipleOf: s.value,
+        message: s.message
+      }), a.dirty()) : s.kind === "finite" ? Number.isFinite(e.data) || (n = this._getOrReturnCtx(e, n), h(n, {
+        code: d.not_finite,
+        message: s.message
+      }), a.dirty()) : T.assertNever(s);
+    return { status: a.value, value: e.data };
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, v.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, v.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, v.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, v.toString(t));
+  }
+  setLimit(e, t, n, a) {
+    return new ne({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: n,
+          message: v.toString(a)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new ne({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  int(e) {
+    return this._addCheck({
+      kind: "int",
+      message: v.toString(e)
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !1,
+      message: v.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !1,
+      message: v.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !0,
+      message: v.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !0,
+      message: v.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: v.toString(t)
+    });
+  }
+  finite(e) {
+    return this._addCheck({
+      kind: "finite",
+      message: v.toString(e)
+    });
+  }
+  safe(e) {
+    return this._addCheck({
+      kind: "min",
+      inclusive: !0,
+      value: Number.MIN_SAFE_INTEGER,
+      message: v.toString(e)
+    })._addCheck({
+      kind: "max",
+      inclusive: !0,
+      value: Number.MAX_SAFE_INTEGER,
+      message: v.toString(e)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e;
+  }
+  get isInt() {
+    return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" && T.isInteger(e.value));
+  }
+  get isFinite() {
+    let e = null, t = null;
+    for (const n of this._def.checks) {
+      if (n.kind === "finite" || n.kind === "int" || n.kind === "multipleOf")
+        return !0;
+      n.kind === "min" ? (t === null || n.value > t) && (t = n.value) : n.kind === "max" && (e === null || n.value < e) && (e = n.value);
+    }
+    return Number.isFinite(t) && Number.isFinite(e);
+  }
+}
+ne.create = (r) => new ne({
+  checks: [],
+  typeName: g.ZodNumber,
+  coerce: (r == null ? void 0 : r.coerce) || !1,
+  ...x(r)
+});
+class ae extends k {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte;
+  }
+  _parse(e) {
+    if (this._def.coerce && (e.data = BigInt(e.data)), this._getType(e) !== m.bigint) {
+      const s = this._getOrReturnCtx(e);
+      return h(s, {
+        code: d.invalid_type,
+        expected: m.bigint,
+        received: s.parsedType
+      }), _;
+    }
+    let n;
+    const a = new D();
+    for (const s of this._def.checks)
+      s.kind === "min" ? (s.inclusive ? e.data < s.value : e.data <= s.value) && (n = this._getOrReturnCtx(e, n), h(n, {
+        code: d.too_small,
+        type: "bigint",
+        minimum: s.value,
+        inclusive: s.inclusive,
+        message: s.message
+      }), a.dirty()) : s.kind === "max" ? (s.inclusive ? e.data > s.value : e.data >= s.value) && (n = this._getOrReturnCtx(e, n), h(n, {
+        code: d.too_big,
+        type: "bigint",
+        maximum: s.value,
+        inclusive: s.inclusive,
+        message: s.message
+      }), a.dirty()) : s.kind === "multipleOf" ? e.data % s.value !== BigInt(0) && (n = this._getOrReturnCtx(e, n), h(n, {
+        code: d.not_multiple_of,
+        multipleOf: s.value,
+        message: s.message
+      }), a.dirty()) : T.assertNever(s);
+    return { status: a.value, value: e.data };
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, v.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, v.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, v.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, v.toString(t));
+  }
+  setLimit(e, t, n, a) {
+    return new ae({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: n,
+          message: v.toString(a)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new ae({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !1,
+      message: v.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !1,
+      message: v.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !0,
+      message: v.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !0,
+      message: v.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: v.toString(t)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e;
+  }
+}
+ae.create = (r) => {
+  var e;
+  return new ae({
+    checks: [],
+    typeName: g.ZodBigInt,
+    coerce: (e = r == null ? void 0 : r.coerce) !== null && e !== void 0 ? e : !1,
+    ...x(r)
+  });
+};
+class Ze extends k {
+  _parse(e) {
+    if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== m.boolean) {
+      const n = this._getOrReturnCtx(e);
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.boolean,
+        received: n.parsedType
+      }), _;
+    }
+    return M(e.data);
+  }
+}
+Ze.create = (r) => new Ze({
+  typeName: g.ZodBoolean,
+  coerce: (r == null ? void 0 : r.coerce) || !1,
+  ...x(r)
+});
+class le extends k {
+  _parse(e) {
+    if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== m.date) {
+      const s = this._getOrReturnCtx(e);
+      return h(s, {
+        code: d.invalid_type,
+        expected: m.date,
+        received: s.parsedType
+      }), _;
+    }
+    if (isNaN(e.data.getTime())) {
+      const s = this._getOrReturnCtx(e);
+      return h(s, {
+        code: d.invalid_date
+      }), _;
+    }
+    const n = new D();
+    let a;
+    for (const s of this._def.checks)
+      s.kind === "min" ? e.data.getTime() < s.value && (a = this._getOrReturnCtx(e, a), h(a, {
+        code: d.too_small,
+        message: s.message,
+        inclusive: !0,
+        exact: !1,
+        minimum: s.value,
+        type: "date"
+      }), n.dirty()) : s.kind === "max" ? e.data.getTime() > s.value && (a = this._getOrReturnCtx(e, a), h(a, {
+        code: d.too_big,
+        message: s.message,
+        inclusive: !0,
+        exact: !1,
+        maximum: s.value,
+        type: "date"
+      }), n.dirty()) : T.assertNever(s);
+    return {
+      status: n.value,
+      value: new Date(e.data.getTime())
+    };
+  }
+  _addCheck(e) {
+    return new le({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e.getTime(),
+      message: v.toString(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e.getTime(),
+      message: v.toString(t)
+    });
+  }
+  get minDate() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e != null ? new Date(e) : null;
+  }
+  get maxDate() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e != null ? new Date(e) : null;
+  }
+}
+le.create = (r) => new le({
+  checks: [],
+  coerce: (r == null ? void 0 : r.coerce) || !1,
+  typeName: g.ZodDate,
+  ...x(r)
+});
+class at extends k {
+  _parse(e) {
+    if (this._getType(e) !== m.symbol) {
+      const n = this._getOrReturnCtx(e);
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.symbol,
+        received: n.parsedType
+      }), _;
+    }
+    return M(e.data);
+  }
+}
+at.create = (r) => new at({
+  typeName: g.ZodSymbol,
+  ...x(r)
+});
+class Pe extends k {
+  _parse(e) {
+    if (this._getType(e) !== m.undefined) {
+      const n = this._getOrReturnCtx(e);
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.undefined,
+        received: n.parsedType
+      }), _;
+    }
+    return M(e.data);
+  }
+}
+Pe.create = (r) => new Pe({
+  typeName: g.ZodUndefined,
+  ...x(r)
+});
+class Ae extends k {
+  _parse(e) {
+    if (this._getType(e) !== m.null) {
+      const n = this._getOrReturnCtx(e);
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.null,
+        received: n.parsedType
+      }), _;
+    }
+    return M(e.data);
+  }
+}
+Ae.create = (r) => new Ae({
+  typeName: g.ZodNull,
+  ...x(r)
+});
+class ke extends k {
+  constructor() {
+    super(...arguments), this._any = !0;
+  }
+  _parse(e) {
+    return M(e.data);
+  }
+}
+ke.create = (r) => new ke({
+  typeName: g.ZodAny,
+  ...x(r)
+});
+class ue extends k {
+  constructor() {
+    super(...arguments), this._unknown = !0;
+  }
+  _parse(e) {
+    return M(e.data);
+  }
+}
+ue.create = (r) => new ue({
+  typeName: g.ZodUnknown,
+  ...x(r)
+});
+class X extends k {
+  _parse(e) {
+    const t = this._getOrReturnCtx(e);
+    return h(t, {
+      code: d.invalid_type,
+      expected: m.never,
+      received: t.parsedType
+    }), _;
+  }
+}
+X.create = (r) => new X({
+  typeName: g.ZodNever,
+  ...x(r)
+});
+class st extends k {
+  _parse(e) {
+    if (this._getType(e) !== m.undefined) {
+      const n = this._getOrReturnCtx(e);
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.void,
+        received: n.parsedType
+      }), _;
+    }
+    return M(e.data);
+  }
+}
+st.create = (r) => new st({
+  typeName: g.ZodVoid,
+  ...x(r)
+});
+class F extends k {
+  _parse(e) {
+    const { ctx: t, status: n } = this._processInputParams(e), a = this._def;
+    if (t.parsedType !== m.array)
+      return h(t, {
+        code: d.invalid_type,
+        expected: m.array,
+        received: t.parsedType
+      }), _;
+    if (a.exactLength !== null) {
+      const o = t.data.length > a.exactLength.value, c = t.data.length < a.exactLength.value;
+      (o || c) && (h(t, {
+        code: o ? d.too_big : d.too_small,
+        minimum: c ? a.exactLength.value : void 0,
+        maximum: o ? a.exactLength.value : void 0,
+        type: "array",
+        inclusive: !0,
+        exact: !0,
+        message: a.exactLength.message
+      }), n.dirty());
+    }
+    if (a.minLength !== null && t.data.length < a.minLength.value && (h(t, {
+      code: d.too_small,
+      minimum: a.minLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: a.minLength.message
+    }), n.dirty()), a.maxLength !== null && t.data.length > a.maxLength.value && (h(t, {
+      code: d.too_big,
+      maximum: a.maxLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: a.maxLength.message
+    }), n.dirty()), t.common.async)
+      return Promise.all([...t.data].map((o, c) => a.type._parseAsync(new H(t, o, t.path, c)))).then((o) => D.mergeArray(n, o));
+    const s = [...t.data].map((o, c) => a.type._parseSync(new H(t, o, t.path, c)));
+    return D.mergeArray(n, s);
+  }
+  get element() {
+    return this._def.type;
+  }
+  min(e, t) {
+    return new F({
+      ...this._def,
+      minLength: { value: e, message: v.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new F({
+      ...this._def,
+      maxLength: { value: e, message: v.toString(t) }
+    });
+  }
+  length(e, t) {
+    return new F({
+      ...this._def,
+      exactLength: { value: e, message: v.toString(t) }
+    });
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+F.create = (r, e) => new F({
+  type: r,
+  minLength: null,
+  maxLength: null,
+  exactLength: null,
+  typeName: g.ZodArray,
+  ...x(e)
+});
+function ge(r) {
+  if (r instanceof O) {
+    const e = {};
+    for (const t in r.shape) {
+      const n = r.shape[t];
+      e[t] = J.create(ge(n));
+    }
+    return new O({
+      ...r._def,
+      shape: () => e
+    });
+  } else return r instanceof F ? new F({
+    ...r._def,
+    type: ge(r.element)
+  }) : r instanceof J ? J.create(ge(r.unwrap())) : r instanceof ie ? ie.create(ge(r.unwrap())) : r instanceof G ? G.create(r.items.map((e) => ge(e))) : r;
+}
+class O extends k {
+  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(), t = T.objectKeys(e);
+    return this._cached = { shape: e, keys: t };
+  }
+  _parse(e) {
+    if (this._getType(e) !== m.object) {
+      const l = this._getOrReturnCtx(e);
+      return h(l, {
+        code: d.invalid_type,
+        expected: m.object,
+        received: l.parsedType
+      }), _;
+    }
+    const { status: n, ctx: a } = this._processInputParams(e), { shape: s, keys: o } = this._getCached(), c = [];
+    if (!(this._def.catchall instanceof X && this._def.unknownKeys === "strip"))
+      for (const l in a.data)
+        o.includes(l) || c.push(l);
+    const f = [];
+    for (const l of o) {
+      const y = s[l], j = a.data[l];
+      f.push({
+        key: { status: "valid", value: l },
+        value: y._parse(new H(a, j, a.path, l)),
+        alwaysSet: l in a.data
+      });
+    }
+    if (this._def.catchall instanceof X) {
+      const l = this._def.unknownKeys;
+      if (l === "passthrough")
+        for (const y of c)
+          f.push({
+            key: { status: "valid", value: y },
+            value: { status: "valid", value: a.data[y] }
+          });
+      else if (l === "strict")
+        c.length > 0 && (h(a, {
+          code: d.unrecognized_keys,
+          keys: c
+        }), n.dirty());
+      else if (l !== "strip") throw new Error("Internal ZodObject error: invalid unknownKeys value.");
+    } else {
+      const l = this._def.catchall;
+      for (const y of c) {
+        const j = a.data[y];
+        f.push({
+          key: { status: "valid", value: y },
+          value: l._parse(
+            new H(a, j, a.path, y)
+            //, ctx.child(key), value, getParsedType(value)
+          ),
+          alwaysSet: y in a.data
+        });
+      }
+    }
+    return a.common.async ? Promise.resolve().then(async () => {
+      const l = [];
+      for (const y of f) {
+        const j = await y.key, z = await y.value;
+        l.push({
+          key: j,
+          value: z,
+          alwaysSet: y.alwaysSet
+        });
+      }
+      return l;
+    }).then((l) => D.mergeObjectSync(n, l)) : D.mergeObjectSync(n, f);
+  }
+  get shape() {
+    return this._def.shape();
+  }
+  strict(e) {
+    return v.errToObj, new O({
+      ...this._def,
+      unknownKeys: "strict",
+      ...e !== void 0 ? {
+        errorMap: (t, n) => {
+          var a, s, o, c;
+          const f = (o = (s = (a = this._def).errorMap) === null || s === void 0 ? void 0 : s.call(a, t, n).message) !== null && o !== void 0 ? o : n.defaultError;
+          return t.code === "unrecognized_keys" ? {
+            message: (c = v.errToObj(e).message) !== null && c !== void 0 ? c : f
+          } : {
+            message: f
+          };
+        }
+      } : {}
+    });
+  }
+  strip() {
+    return new O({
+      ...this._def,
+      unknownKeys: "strip"
+    });
+  }
+  passthrough() {
+    return new O({
+      ...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 O({
+      ...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 O({
+      unknownKeys: e._def.unknownKeys,
+      catchall: e._def.catchall,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e._def.shape()
+      }),
+      typeName: g.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, t) {
+    return this.augment({ [e]: t });
+  }
+  // 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 O({
+      ...this._def,
+      catchall: e
+    });
+  }
+  pick(e) {
+    const t = {};
+    return T.objectKeys(e).forEach((n) => {
+      e[n] && this.shape[n] && (t[n] = this.shape[n]);
+    }), new O({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  omit(e) {
+    const t = {};
+    return T.objectKeys(this.shape).forEach((n) => {
+      e[n] || (t[n] = this.shape[n]);
+    }), new O({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  /**
+   * @deprecated
+   */
+  deepPartial() {
+    return ge(this);
+  }
+  partial(e) {
+    const t = {};
+    return T.objectKeys(this.shape).forEach((n) => {
+      const a = this.shape[n];
+      e && !e[n] ? t[n] = a : t[n] = a.optional();
+    }), new O({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  required(e) {
+    const t = {};
+    return T.objectKeys(this.shape).forEach((n) => {
+      if (e && !e[n])
+        t[n] = this.shape[n];
+      else {
+        let s = this.shape[n];
+        for (; s instanceof J; )
+          s = s._def.innerType;
+        t[n] = s;
+      }
+    }), new O({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  keyof() {
+    return hr(T.objectKeys(this.shape));
+  }
+}
+O.create = (r, e) => new O({
+  shape: () => r,
+  unknownKeys: "strip",
+  catchall: X.create(),
+  typeName: g.ZodObject,
+  ...x(e)
+});
+O.strictCreate = (r, e) => new O({
+  shape: () => r,
+  unknownKeys: "strict",
+  catchall: X.create(),
+  typeName: g.ZodObject,
+  ...x(e)
+});
+O.lazycreate = (r, e) => new O({
+  shape: r,
+  unknownKeys: "strip",
+  catchall: X.create(),
+  typeName: g.ZodObject,
+  ...x(e)
+});
+class De extends k {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), n = this._def.options;
+    function a(s) {
+      for (const c of s)
+        if (c.result.status === "valid")
+          return c.result;
+      for (const c of s)
+        if (c.result.status === "dirty")
+          return t.common.issues.push(...c.ctx.common.issues), c.result;
+      const o = s.map((c) => new U(c.ctx.common.issues));
+      return h(t, {
+        code: d.invalid_union,
+        unionErrors: o
+      }), _;
+    }
+    if (t.common.async)
+      return Promise.all(n.map(async (s) => {
+        const o = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        };
+        return {
+          result: await s._parseAsync({
+            data: t.data,
+            path: t.path,
+            parent: o
+          }),
+          ctx: o
+        };
+      })).then(a);
+    {
+      let s;
+      const o = [];
+      for (const f of n) {
+        const l = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        }, y = f._parseSync({
+          data: t.data,
+          path: t.path,
+          parent: l
+        });
+        if (y.status === "valid")
+          return y;
+        y.status === "dirty" && !s && (s = { result: y, ctx: l }), l.common.issues.length && o.push(l.common.issues);
+      }
+      if (s)
+        return t.common.issues.push(...s.ctx.common.issues), s.result;
+      const c = o.map((f) => new U(f));
+      return h(t, {
+        code: d.invalid_union,
+        unionErrors: c
+      }), _;
+    }
+  }
+  get options() {
+    return this._def.options;
+  }
+}
+De.create = (r, e) => new De({
+  options: r,
+  typeName: g.ZodUnion,
+  ...x(e)
+});
+const K = (r) => r instanceof Me ? K(r.schema) : r instanceof Y ? K(r.innerType()) : r instanceof Le ? [r.value] : r instanceof se ? r.options : r instanceof Ue ? T.objectValues(r.enum) : r instanceof ze ? K(r._def.innerType) : r instanceof Pe ? [void 0] : r instanceof Ae ? [null] : r instanceof J ? [void 0, ...K(r.unwrap())] : r instanceof ie ? [null, ...K(r.unwrap())] : r instanceof jt || r instanceof Be ? K(r.unwrap()) : r instanceof We ? K(r._def.innerType) : [];
+class ct extends k {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== m.object)
+      return h(t, {
+        code: d.invalid_type,
+        expected: m.object,
+        received: t.parsedType
+      }), _;
+    const n = this.discriminator, a = t.data[n], s = this.optionsMap.get(a);
+    return s ? t.common.async ? s._parseAsync({
+      data: t.data,
+      path: t.path,
+      parent: t
+    }) : s._parseSync({
+      data: t.data,
+      path: t.path,
+      parent: t
+    }) : (h(t, {
+      code: d.invalid_union_discriminator,
+      options: Array.from(this.optionsMap.keys()),
+      path: [n]
+    }), _);
+  }
+  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, t, n) {
+    const a = /* @__PURE__ */ new Map();
+    for (const s of t) {
+      const o = K(s.shape[e]);
+      if (!o.length)
+        throw new Error(`A discriminator value for key \`${e}\` could not be extracted from all schema options`);
+      for (const c of o) {
+        if (a.has(c))
+          throw new Error(`Discriminator property ${String(e)} has duplicate value ${String(c)}`);
+        a.set(c, s);
+      }
+    }
+    return new ct({
+      typeName: g.ZodDiscriminatedUnion,
+      discriminator: e,
+      options: t,
+      optionsMap: a,
+      ...x(n)
+    });
+  }
+}
+function Ot(r, e) {
+  const t = re(r), n = re(e);
+  if (r === e)
+    return { valid: !0, data: r };
+  if (t === m.object && n === m.object) {
+    const a = T.objectKeys(e), s = T.objectKeys(r).filter((c) => a.indexOf(c) !== -1), o = { ...r, ...e };
+    for (const c of s) {
+      const f = Ot(r[c], e[c]);
+      if (!f.valid)
+        return { valid: !1 };
+      o[c] = f.data;
+    }
+    return { valid: !0, data: o };
+  } else if (t === m.array && n === m.array) {
+    if (r.length !== e.length)
+      return { valid: !1 };
+    const a = [];
+    for (let s = 0; s < r.length; s++) {
+      const o = r[s], c = e[s], f = Ot(o, c);
+      if (!f.valid)
+        return { valid: !1 };
+      a.push(f.data);
+    }
+    return { valid: !0, data: a };
+  } else return t === m.date && n === m.date && +r == +e ? { valid: !0, data: r } : { valid: !1 };
+}
+class $e extends k {
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e), a = (s, o) => {
+      if (St(s) || St(o))
+        return _;
+      const c = Ot(s.value, o.value);
+      return c.valid ? ((Ct(s) || Ct(o)) && t.dirty(), { status: t.value, value: c.data }) : (h(n, {
+        code: d.invalid_intersection_types
+      }), _);
+    };
+    return n.common.async ? Promise.all([
+      this._def.left._parseAsync({
+        data: n.data,
+        path: n.path,
+        parent: n
+      }),
+      this._def.right._parseAsync({
+        data: n.data,
+        path: n.path,
+        parent: n
+      })
+    ]).then(([s, o]) => a(s, o)) : a(this._def.left._parseSync({
+      data: n.data,
+      path: n.path,
+      parent: n
+    }), this._def.right._parseSync({
+      data: n.data,
+      path: n.path,
+      parent: n
+    }));
+  }
+}
+$e.create = (r, e, t) => new $e({
+  left: r,
+  right: e,
+  typeName: g.ZodIntersection,
+  ...x(t)
+});
+class G extends k {
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.parsedType !== m.array)
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.array,
+        received: n.parsedType
+      }), _;
+    if (n.data.length < this._def.items.length)
+      return h(n, {
+        code: d.too_small,
+        minimum: this._def.items.length,
+        inclusive: !0,
+        exact: !1,
+        type: "array"
+      }), _;
+    !this._def.rest && n.data.length > this._def.items.length && (h(n, {
+      code: d.too_big,
+      maximum: this._def.items.length,
+      inclusive: !0,
+      exact: !1,
+      type: "array"
+    }), t.dirty());
+    const s = [...n.data].map((o, c) => {
+      const f = this._def.items[c] || this._def.rest;
+      return f ? f._parse(new H(n, o, n.path, c)) : null;
+    }).filter((o) => !!o);
+    return n.common.async ? Promise.all(s).then((o) => D.mergeArray(t, o)) : D.mergeArray(t, s);
+  }
+  get items() {
+    return this._def.items;
+  }
+  rest(e) {
+    return new G({
+      ...this._def,
+      rest: e
+    });
+  }
+}
+G.create = (r, e) => {
+  if (!Array.isArray(r))
+    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+  return new G({
+    items: r,
+    typeName: g.ZodTuple,
+    rest: null,
+    ...x(e)
+  });
+};
+class Ve extends k {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.parsedType !== m.object)
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.object,
+        received: n.parsedType
+      }), _;
+    const a = [], s = this._def.keyType, o = this._def.valueType;
+    for (const c in n.data)
+      a.push({
+        key: s._parse(new H(n, c, n.path, c)),
+        value: o._parse(new H(n, n.data[c], n.path, c)),
+        alwaysSet: c in n.data
+      });
+    return n.common.async ? D.mergeObjectAsync(t, a) : D.mergeObjectSync(t, a);
+  }
+  get element() {
+    return this._def.valueType;
+  }
+  static create(e, t, n) {
+    return t instanceof k ? new Ve({
+      keyType: e,
+      valueType: t,
+      typeName: g.ZodRecord,
+      ...x(n)
+    }) : new Ve({
+      keyType: B.create(),
+      valueType: e,
+      typeName: g.ZodRecord,
+      ...x(t)
+    });
+  }
+}
+class it extends k {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.parsedType !== m.map)
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.map,
+        received: n.parsedType
+      }), _;
+    const a = this._def.keyType, s = this._def.valueType, o = [...n.data.entries()].map(([c, f], l) => ({
+      key: a._parse(new H(n, c, n.path, [l, "key"])),
+      value: s._parse(new H(n, f, n.path, [l, "value"]))
+    }));
+    if (n.common.async) {
+      const c = /* @__PURE__ */ new Map();
+      return Promise.resolve().then(async () => {
+        for (const f of o) {
+          const l = await f.key, y = await f.value;
+          if (l.status === "aborted" || y.status === "aborted")
+            return _;
+          (l.status === "dirty" || y.status === "dirty") && t.dirty(), c.set(l.value, y.value);
+        }
+        return { status: t.value, value: c };
+      });
+    } else {
+      const c = /* @__PURE__ */ new Map();
+      for (const f of o) {
+        const l = f.key, y = f.value;
+        if (l.status === "aborted" || y.status === "aborted")
+          return _;
+        (l.status === "dirty" || y.status === "dirty") && t.dirty(), c.set(l.value, y.value);
+      }
+      return { status: t.value, value: c };
+    }
+  }
+}
+it.create = (r, e, t) => new it({
+  valueType: e,
+  keyType: r,
+  typeName: g.ZodMap,
+  ...x(t)
+});
+class fe extends k {
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.parsedType !== m.set)
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.set,
+        received: n.parsedType
+      }), _;
+    const a = this._def;
+    a.minSize !== null && n.data.size < a.minSize.value && (h(n, {
+      code: d.too_small,
+      minimum: a.minSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: a.minSize.message
+    }), t.dirty()), a.maxSize !== null && n.data.size > a.maxSize.value && (h(n, {
+      code: d.too_big,
+      maximum: a.maxSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: a.maxSize.message
+    }), t.dirty());
+    const s = this._def.valueType;
+    function o(f) {
+      const l = /* @__PURE__ */ new Set();
+      for (const y of f) {
+        if (y.status === "aborted")
+          return _;
+        y.status === "dirty" && t.dirty(), l.add(y.value);
+      }
+      return { status: t.value, value: l };
+    }
+    const c = [...n.data.values()].map((f, l) => s._parse(new H(n, f, n.path, l)));
+    return n.common.async ? Promise.all(c).then((f) => o(f)) : o(c);
+  }
+  min(e, t) {
+    return new fe({
+      ...this._def,
+      minSize: { value: e, message: v.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new fe({
+      ...this._def,
+      maxSize: { value: e, message: v.toString(t) }
+    });
+  }
+  size(e, t) {
+    return this.min(e, t).max(e, t);
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+fe.create = (r, e) => new fe({
+  valueType: r,
+  minSize: null,
+  maxSize: null,
+  typeName: g.ZodSet,
+  ...x(e)
+});
+class be extends k {
+  constructor() {
+    super(...arguments), this.validate = this.implement;
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== m.function)
+      return h(t, {
+        code: d.invalid_type,
+        expected: m.function,
+        received: t.parsedType
+      }), _;
+    function n(c, f) {
+      return rt({
+        data: c,
+        path: t.path,
+        errorMaps: [
+          t.common.contextualErrorMap,
+          t.schemaErrorMap,
+          tt(),
+          xe
+        ].filter((l) => !!l),
+        issueData: {
+          code: d.invalid_arguments,
+          argumentsError: f
+        }
+      });
+    }
+    function a(c, f) {
+      return rt({
+        data: c,
+        path: t.path,
+        errorMaps: [
+          t.common.contextualErrorMap,
+          t.schemaErrorMap,
+          tt(),
+          xe
+        ].filter((l) => !!l),
+        issueData: {
+          code: d.invalid_return_type,
+          returnTypeError: f
+        }
+      });
+    }
+    const s = { errorMap: t.common.contextualErrorMap }, o = t.data;
+    if (this._def.returns instanceof we) {
+      const c = this;
+      return M(async function(...f) {
+        const l = new U([]), y = await c._def.args.parseAsync(f, s).catch((P) => {
+          throw l.addIssue(n(f, P)), l;
+        }), j = await Reflect.apply(o, this, y);
+        return await c._def.returns._def.type.parseAsync(j, s).catch((P) => {
+          throw l.addIssue(a(j, P)), l;
+        });
+      });
+    } else {
+      const c = this;
+      return M(function(...f) {
+        const l = c._def.args.safeParse(f, s);
+        if (!l.success)
+          throw new U([n(f, l.error)]);
+        const y = Reflect.apply(o, this, l.data), j = c._def.returns.safeParse(y, s);
+        if (!j.success)
+          throw new U([a(y, j.error)]);
+        return j.data;
+      });
+    }
+  }
+  parameters() {
+    return this._def.args;
+  }
+  returnType() {
+    return this._def.returns;
+  }
+  args(...e) {
+    return new be({
+      ...this._def,
+      args: G.create(e).rest(ue.create())
+    });
+  }
+  returns(e) {
+    return new be({
+      ...this._def,
+      returns: e
+    });
+  }
+  implement(e) {
+    return this.parse(e);
+  }
+  strictImplement(e) {
+    return this.parse(e);
+  }
+  static create(e, t, n) {
+    return new be({
+      args: e || G.create([]).rest(ue.create()),
+      returns: t || ue.create(),
+      typeName: g.ZodFunction,
+      ...x(n)
+    });
+  }
+}
+class Me extends k {
+  get schema() {
+    return this._def.getter();
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    return this._def.getter()._parse({ data: t.data, path: t.path, parent: t });
+  }
+}
+Me.create = (r, e) => new Me({
+  getter: r,
+  typeName: g.ZodLazy,
+  ...x(e)
+});
+class Le extends k {
+  _parse(e) {
+    if (e.data !== this._def.value) {
+      const t = this._getOrReturnCtx(e);
+      return h(t, {
+        received: t.data,
+        code: d.invalid_literal,
+        expected: this._def.value
+      }), _;
+    }
+    return { status: "valid", value: e.data };
+  }
+  get value() {
+    return this._def.value;
+  }
+}
+Le.create = (r, e) => new Le({
+  value: r,
+  typeName: g.ZodLiteral,
+  ...x(e)
+});
+function hr(r, e) {
+  return new se({
+    values: r,
+    typeName: g.ZodEnum,
+    ...x(e)
+  });
+}
+class se extends k {
+  constructor() {
+    super(...arguments), Oe.set(this, void 0);
+  }
+  _parse(e) {
+    if (typeof e.data != "string") {
+      const t = this._getOrReturnCtx(e), n = this._def.values;
+      return h(t, {
+        expected: T.joinValues(n),
+        received: t.parsedType,
+        code: d.invalid_type
+      }), _;
+    }
+    if (nt(this, Oe) || ur(this, Oe, new Set(this._def.values)), !nt(this, Oe).has(e.data)) {
+      const t = this._getOrReturnCtx(e), n = this._def.values;
+      return h(t, {
+        received: t.data,
+        code: d.invalid_enum_value,
+        options: n
+      }), _;
+    }
+    return M(e.data);
+  }
+  get options() {
+    return this._def.values;
+  }
+  get enum() {
+    const e = {};
+    for (const t of this._def.values)
+      e[t] = t;
+    return e;
+  }
+  get Values() {
+    const e = {};
+    for (const t of this._def.values)
+      e[t] = t;
+    return e;
+  }
+  get Enum() {
+    const e = {};
+    for (const t of this._def.values)
+      e[t] = t;
+    return e;
+  }
+  extract(e, t = this._def) {
+    return se.create(e, {
+      ...this._def,
+      ...t
+    });
+  }
+  exclude(e, t = this._def) {
+    return se.create(this.options.filter((n) => !e.includes(n)), {
+      ...this._def,
+      ...t
+    });
+  }
+}
+Oe = /* @__PURE__ */ new WeakMap();
+se.create = hr;
+class Ue extends k {
+  constructor() {
+    super(...arguments), je.set(this, void 0);
+  }
+  _parse(e) {
+    const t = T.getValidEnumValues(this._def.values), n = this._getOrReturnCtx(e);
+    if (n.parsedType !== m.string && n.parsedType !== m.number) {
+      const a = T.objectValues(t);
+      return h(n, {
+        expected: T.joinValues(a),
+        received: n.parsedType,
+        code: d.invalid_type
+      }), _;
+    }
+    if (nt(this, je) || ur(this, je, new Set(T.getValidEnumValues(this._def.values))), !nt(this, je).has(e.data)) {
+      const a = T.objectValues(t);
+      return h(n, {
+        received: n.data,
+        code: d.invalid_enum_value,
+        options: a
+      }), _;
+    }
+    return M(e.data);
+  }
+  get enum() {
+    return this._def.values;
+  }
+}
+je = /* @__PURE__ */ new WeakMap();
+Ue.create = (r, e) => new Ue({
+  values: r,
+  typeName: g.ZodNativeEnum,
+  ...x(e)
+});
+class we extends k {
+  unwrap() {
+    return this._def.type;
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== m.promise && t.common.async === !1)
+      return h(t, {
+        code: d.invalid_type,
+        expected: m.promise,
+        received: t.parsedType
+      }), _;
+    const n = t.parsedType === m.promise ? t.data : Promise.resolve(t.data);
+    return M(n.then((a) => this._def.type.parseAsync(a, {
+      path: t.path,
+      errorMap: t.common.contextualErrorMap
+    })));
+  }
+}
+we.create = (r, e) => new we({
+  type: r,
+  typeName: g.ZodPromise,
+  ...x(e)
+});
+class Y extends k {
+  innerType() {
+    return this._def.schema;
+  }
+  sourceType() {
+    return this._def.schema._def.typeName === g.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e), a = this._def.effect || null, s = {
+      addIssue: (o) => {
+        h(n, o), o.fatal ? t.abort() : t.dirty();
+      },
+      get path() {
+        return n.path;
+      }
+    };
+    if (s.addIssue = s.addIssue.bind(s), a.type === "preprocess") {
+      const o = a.transform(n.data, s);
+      if (n.common.async)
+        return Promise.resolve(o).then(async (c) => {
+          if (t.value === "aborted")
+            return _;
+          const f = await this._def.schema._parseAsync({
+            data: c,
+            path: n.path,
+            parent: n
+          });
+          return f.status === "aborted" ? _ : f.status === "dirty" || t.value === "dirty" ? _e(f.value) : f;
+        });
+      {
+        if (t.value === "aborted")
+          return _;
+        const c = this._def.schema._parseSync({
+          data: o,
+          path: n.path,
+          parent: n
+        });
+        return c.status === "aborted" ? _ : c.status === "dirty" || t.value === "dirty" ? _e(c.value) : c;
+      }
+    }
+    if (a.type === "refinement") {
+      const o = (c) => {
+        const f = a.refinement(c, s);
+        if (n.common.async)
+          return Promise.resolve(f);
+        if (f instanceof Promise)
+          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+        return c;
+      };
+      if (n.common.async === !1) {
+        const c = this._def.schema._parseSync({
+          data: n.data,
+          path: n.path,
+          parent: n
+        });
+        return c.status === "aborted" ? _ : (c.status === "dirty" && t.dirty(), o(c.value), { status: t.value, value: c.value });
+      } else
+        return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((c) => c.status === "aborted" ? _ : (c.status === "dirty" && t.dirty(), o(c.value).then(() => ({ status: t.value, value: c.value }))));
+    }
+    if (a.type === "transform")
+      if (n.common.async === !1) {
+        const o = this._def.schema._parseSync({
+          data: n.data,
+          path: n.path,
+          parent: n
+        });
+        if (!Ne(o))
+          return o;
+        const c = a.transform(o.value, s);
+        if (c instanceof Promise)
+          throw new Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
+        return { status: t.value, value: c };
+      } else
+        return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((o) => Ne(o) ? Promise.resolve(a.transform(o.value, s)).then((c) => ({ status: t.value, value: c })) : o);
+    T.assertNever(a);
+  }
+}
+Y.create = (r, e, t) => new Y({
+  schema: r,
+  typeName: g.ZodEffects,
+  effect: e,
+  ...x(t)
+});
+Y.createWithPreprocess = (r, e, t) => new Y({
+  schema: e,
+  effect: { type: "preprocess", transform: r },
+  typeName: g.ZodEffects,
+  ...x(t)
+});
+class J extends k {
+  _parse(e) {
+    return this._getType(e) === m.undefined ? M(void 0) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+J.create = (r, e) => new J({
+  innerType: r,
+  typeName: g.ZodOptional,
+  ...x(e)
+});
+class ie extends k {
+  _parse(e) {
+    return this._getType(e) === m.null ? M(null) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+ie.create = (r, e) => new ie({
+  innerType: r,
+  typeName: g.ZodNullable,
+  ...x(e)
+});
+class ze extends k {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    let n = t.data;
+    return t.parsedType === m.undefined && (n = this._def.defaultValue()), this._def.innerType._parse({
+      data: n,
+      path: t.path,
+      parent: t
+    });
+  }
+  removeDefault() {
+    return this._def.innerType;
+  }
+}
+ze.create = (r, e) => new ze({
+  innerType: r,
+  typeName: g.ZodDefault,
+  defaultValue: typeof e.default == "function" ? e.default : () => e.default,
+  ...x(e)
+});
+class We extends k {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), n = {
+      ...t,
+      common: {
+        ...t.common,
+        issues: []
+      }
+    }, a = this._def.innerType._parse({
+      data: n.data,
+      path: n.path,
+      parent: {
+        ...n
+      }
+    });
+    return Ie(a) ? a.then((s) => ({
+      status: "valid",
+      value: s.status === "valid" ? s.value : this._def.catchValue({
+        get error() {
+          return new U(n.common.issues);
+        },
+        input: n.data
+      })
+    })) : {
+      status: "valid",
+      value: a.status === "valid" ? a.value : this._def.catchValue({
+        get error() {
+          return new U(n.common.issues);
+        },
+        input: n.data
+      })
+    };
+  }
+  removeCatch() {
+    return this._def.innerType;
+  }
+}
+We.create = (r, e) => new We({
+  innerType: r,
+  typeName: g.ZodCatch,
+  catchValue: typeof e.catch == "function" ? e.catch : () => e.catch,
+  ...x(e)
+});
+class ot extends k {
+  _parse(e) {
+    if (this._getType(e) !== m.nan) {
+      const n = this._getOrReturnCtx(e);
+      return h(n, {
+        code: d.invalid_type,
+        expected: m.nan,
+        received: n.parsedType
+      }), _;
+    }
+    return { status: "valid", value: e.data };
+  }
+}
+ot.create = (r) => new ot({
+  typeName: g.ZodNaN,
+  ...x(r)
+});
+const yn = Symbol("zod_brand");
+class jt extends k {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), n = t.data;
+    return this._def.type._parse({
+      data: n,
+      path: t.path,
+      parent: t
+    });
+  }
+  unwrap() {
+    return this._def.type;
+  }
+}
+class Fe extends k {
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.common.async)
+      return (async () => {
+        const s = await this._def.in._parseAsync({
+          data: n.data,
+          path: n.path,
+          parent: n
+        });
+        return s.status === "aborted" ? _ : s.status === "dirty" ? (t.dirty(), _e(s.value)) : this._def.out._parseAsync({
+          data: s.value,
+          path: n.path,
+          parent: n
+        });
+      })();
+    {
+      const a = this._def.in._parseSync({
+        data: n.data,
+        path: n.path,
+        parent: n
+      });
+      return a.status === "aborted" ? _ : a.status === "dirty" ? (t.dirty(), {
+        status: "dirty",
+        value: a.value
+      }) : this._def.out._parseSync({
+        data: a.value,
+        path: n.path,
+        parent: n
+      });
+    }
+  }
+  static create(e, t) {
+    return new Fe({
+      in: e,
+      out: t,
+      typeName: g.ZodPipeline
+    });
+  }
+}
+class Be extends k {
+  _parse(e) {
+    const t = this._def.innerType._parse(e), n = (a) => (Ne(a) && (a.value = Object.freeze(a.value)), a);
+    return Ie(t) ? t.then((a) => n(a)) : n(t);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+Be.create = (r, e) => new Be({
+  innerType: r,
+  typeName: g.ZodReadonly,
+  ...x(e)
+});
+function pr(r, e = {}, t) {
+  return r ? ke.create().superRefine((n, a) => {
+    var s, o;
+    if (!r(n)) {
+      const c = typeof e == "function" ? e(n) : typeof e == "string" ? { message: e } : e, f = (o = (s = c.fatal) !== null && s !== void 0 ? s : t) !== null && o !== void 0 ? o : !0, l = typeof c == "string" ? { message: c } : c;
+      a.addIssue({ code: "custom", ...l, fatal: f });
+    }
+  }) : ke.create();
+}
+const gn = {
+  object: O.lazycreate
+};
+var g;
+(function(r) {
+  r.ZodString = "ZodString", r.ZodNumber = "ZodNumber", r.ZodNaN = "ZodNaN", r.ZodBigInt = "ZodBigInt", r.ZodBoolean = "ZodBoolean", r.ZodDate = "ZodDate", r.ZodSymbol = "ZodSymbol", r.ZodUndefined = "ZodUndefined", r.ZodNull = "ZodNull", r.ZodAny = "ZodAny", r.ZodUnknown = "ZodUnknown", r.ZodNever = "ZodNever", r.ZodVoid = "ZodVoid", r.ZodArray = "ZodArray", r.ZodObject = "ZodObject", r.ZodUnion = "ZodUnion", r.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", r.ZodIntersection = "ZodIntersection", r.ZodTuple = "ZodTuple", r.ZodRecord = "ZodRecord", r.ZodMap = "ZodMap", r.ZodSet = "ZodSet", r.ZodFunction = "ZodFunction", r.ZodLazy = "ZodLazy", r.ZodLiteral = "ZodLiteral", r.ZodEnum = "ZodEnum", r.ZodEffects = "ZodEffects", r.ZodNativeEnum = "ZodNativeEnum", r.ZodOptional = "ZodOptional", r.ZodNullable = "ZodNullable", r.ZodDefault = "ZodDefault", r.ZodCatch = "ZodCatch", r.ZodPromise = "ZodPromise", r.ZodBranded = "ZodBranded", r.ZodPipeline = "ZodPipeline", r.ZodReadonly = "ZodReadonly";
+})(g || (g = {}));
+const _n = (r, e = {
+  message: `Input not instance of ${r.name}`
+}) => pr((t) => t instanceof r, e), mr = B.create, vr = ne.create, bn = ot.create, xn = ae.create, yr = Ze.create, kn = le.create, wn = at.create, En = Pe.create, Tn = Ae.create, Rn = ke.create, Sn = ue.create, Cn = X.create, On = st.create, jn = F.create, Nn = O.create, In = O.strictCreate, Zn = De.create, Pn = ct.create, An = $e.create, Dn = G.create, $n = Ve.create, Vn = it.create, Mn = fe.create, Ln = be.create, Un = Me.create, zn = Le.create, Wn = se.create, Bn = Ue.create, Fn = we.create, nr = Y.create, Yn = J.create, qn = ie.create, Jn = Y.createWithPreprocess, Hn = Fe.create, Gn = () => mr().optional(), Kn = () => vr().optional(), Xn = () => yr().optional(), Qn = {
+  string: (r) => B.create({ ...r, coerce: !0 }),
+  number: (r) => ne.create({ ...r, coerce: !0 }),
+  boolean: (r) => Ze.create({
+    ...r,
+    coerce: !0
+  }),
+  bigint: (r) => ae.create({ ...r, coerce: !0 }),
+  date: (r) => le.create({ ...r, coerce: !0 })
+}, ea = _;
+var V = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  defaultErrorMap: xe,
+  setErrorMap: Qr,
+  getErrorMap: tt,
+  makeIssue: rt,
+  EMPTY_PATH: en,
+  addIssueToContext: h,
+  ParseStatus: D,
+  INVALID: _,
+  DIRTY: _e,
+  OK: M,
+  isAborted: St,
+  isDirty: Ct,
+  isValid: Ne,
+  isAsync: Ie,
+  get util() {
+    return T;
+  },
+  get objectUtil() {
+    return Rt;
+  },
+  ZodParsedType: m,
+  getParsedType: re,
+  ZodType: k,
+  datetimeRegex: fr,
+  ZodString: B,
+  ZodNumber: ne,
+  ZodBigInt: ae,
+  ZodBoolean: Ze,
+  ZodDate: le,
+  ZodSymbol: at,
+  ZodUndefined: Pe,
+  ZodNull: Ae,
+  ZodAny: ke,
+  ZodUnknown: ue,
+  ZodNever: X,
+  ZodVoid: st,
+  ZodArray: F,
+  ZodObject: O,
+  ZodUnion: De,
+  ZodDiscriminatedUnion: ct,
+  ZodIntersection: $e,
+  ZodTuple: G,
+  ZodRecord: Ve,
+  ZodMap: it,
+  ZodSet: fe,
+  ZodFunction: be,
+  ZodLazy: Me,
+  ZodLiteral: Le,
+  ZodEnum: se,
+  ZodNativeEnum: Ue,
+  ZodPromise: we,
+  ZodEffects: Y,
+  ZodTransformer: Y,
+  ZodOptional: J,
+  ZodNullable: ie,
+  ZodDefault: ze,
+  ZodCatch: We,
+  ZodNaN: ot,
+  BRAND: yn,
+  ZodBranded: jt,
+  ZodPipeline: Fe,
+  ZodReadonly: Be,
+  custom: pr,
+  Schema: k,
+  ZodSchema: k,
+  late: gn,
+  get ZodFirstPartyTypeKind() {
+    return g;
+  },
+  coerce: Qn,
+  any: Rn,
+  array: jn,
+  bigint: xn,
+  boolean: yr,
+  date: kn,
+  discriminatedUnion: Pn,
+  effect: nr,
+  enum: Wn,
+  function: Ln,
+  instanceof: _n,
+  intersection: An,
+  lazy: Un,
+  literal: zn,
+  map: Vn,
+  nan: bn,
+  nativeEnum: Bn,
+  never: Cn,
+  null: Tn,
+  nullable: qn,
+  number: vr,
+  object: Nn,
+  oboolean: Xn,
+  onumber: Kn,
+  optional: Yn,
+  ostring: Gn,
+  pipeline: Hn,
+  preprocess: Jn,
+  promise: Fn,
+  record: $n,
+  set: Mn,
+  strictObject: In,
+  string: mr,
+  symbol: wn,
+  transformer: nr,
+  tuple: Dn,
+  undefined: En,
+  union: Zn,
+  unknown: Sn,
+  void: On,
+  NEVER: ea,
+  ZodIssueCode: d,
+  quotelessJson: Xr,
+  ZodError: U
+}), A = [];
+for (var wt = 0; wt < 256; ++wt)
+  A.push((wt + 256).toString(16).slice(1));
+function ta(r, e = 0) {
+  return (A[r[e + 0]] + A[r[e + 1]] + A[r[e + 2]] + A[r[e + 3]] + "-" + A[r[e + 4]] + A[r[e + 5]] + "-" + A[r[e + 6]] + A[r[e + 7]] + "-" + A[r[e + 8]] + A[r[e + 9]] + "-" + A[r[e + 10]] + A[r[e + 11]] + A[r[e + 12]] + A[r[e + 13]] + A[r[e + 14]] + A[r[e + 15]]).toLowerCase();
+}
+var Qe, ra = new Uint8Array(16);
+function na() {
+  if (!Qe && (Qe = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !Qe))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return Qe(ra);
+}
+var aa = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const ar = {
+  randomUUID: aa
+};
+function sa(r, e, t) {
+  if (ar.randomUUID && !e && !r)
+    return ar.randomUUID();
+  r = r || {};
+  var n = r.random || (r.rng || na)();
+  return n[6] = n[6] & 15 | 64, n[8] = n[8] & 63 | 128, ta(n);
+}
+const et = "http://localhost:3030", ye = "op-elements";
+var te = ((r) => (r.LOADED = `${ye}-loaded`, r.VALIDATION_ERROR = `${ye}-validation-error`, r.BLUR = `${ye}-blur`, r.FOCUS = `${ye}-focus`, r.CHANGE = `${ye}-change`, r.RESIZE = `${ye}-resize`, r))(te || {});
+const ia = V.object({
+  type: V.nativeEnum(te),
+  payload: V.object({}).catchall(V.string()),
+  nonce: V.string(),
+  formId: V.string(),
+  elementId: V.string()
+}), oa = (r) => {
+  try {
+    return ia.parse(r);
+  } catch (e) {
+    throw console.error("Error parsing event payload:", r, e), e;
+  }
+}, ca = (r, e, t, n, a) => {
+  const s = r.contentWindow;
+  if (!s) {
+    console.error("[form] Cannot emit event, no contentWindow found:", r);
+    return;
+  }
+  const o = {
+    type: n,
+    formId: e,
+    elementId: t,
+    payload: a,
+    nonce: sa()
+  };
+  console.log(`[form] Emitting event ${n} from parent form ${e} to child element ${t}:`, o), s.postMessage(JSON.stringify(o), et);
+}, la = (r) => {
+  const { children: e, className: t, onFocus: n, onBlur: a, onChange: s, onValidationError: o } = r, [c, f] = Ce(""), [l, y] = Ce([]), [j, z] = Ce({}), [P, Ye] = Ce("1px"), he = sr(null);
+  Et(() => f(`op-elements-${window.crypto.randomUUID()}`), []), Et(() => {
+    if (!he.current) return;
+    const N = new ResizeObserver((Ee) => {
+      Ee.forEach((C) => {
+        if (!C.target) return;
+        const { width: ee } = C.contentRect;
+        Object.values(j).forEach((pe) => {
+          pe && ca(pe, c, "root", te.RESIZE, { width: ee.toString() });
+        });
+      });
+    });
+    return N.observe(he.current), () => {
+      N.disconnect();
+    };
+  }, [he, c, j]);
+  const dt = ir(
+    (N, Ee) => {
+      const C = oa(JSON.parse(N.data));
+      if (C.formId !== c) {
+        console.warn("[form] Ignoring event for different form. Expected:", c, "Got:", C.formId);
+        return;
+      }
+      if (C.nonce in l) {
+        console.warn("[form] Ignoring duplicate event:", C);
+        return;
+      }
+      if (y((ee) => [...ee, C.nonce]), console.log("[form] Received event:", C), C.type === te.VALIDATION_ERROR && o)
+        o(C.payload.message, C.elementId);
+      else if (C.type === te.FOCUS && n)
+        n(C.elementId);
+      else if (C.type === te.BLUR && a)
+        a(C.elementId);
+      else if (C.type === te.CHANGE && s)
+        s(C.elementId);
+      else if (C.type === te.LOADED) {
+        const ee = C.elementId;
+        if (!ee) return;
+        z((lt) => ({ ...lt, [ee]: Ee }));
+        const pe = C.payload.height ? `${C.payload.height}px` : "100%";
+        Ye(pe);
+      }
+    },
+    [c, l, o, n, a, s]
+  ), Q = {
+    contextId: c,
+    createToken: () => {
+    },
+    dispatchEvent: dt,
+    formHeight: P
+  };
+  return /* @__PURE__ */ de.jsxDEV(or.Provider, { value: Q, children: /* @__PURE__ */ de.jsxDEV("div", { className: t, ref: he, children: e }, void 0, !1, {
+    fileName: "/home/runner/work/openpay-js-react/openpay-js-react/lib/components/form.tsx",
+    lineNumber: 93,
+    columnNumber: 7
+  }, void 0) }, void 0, !1, {
+    fileName: "/home/runner/work/openpay-js-react/openpay-js-react/lib/components/form.tsx",
+    lineNumber: 92,
+    columnNumber: 5
+  }, void 0);
+};
+V.object({
+  backgroundColor: V.string().optional(),
+  color: V.string().optional(),
+  fontFamily: V.string().optional(),
+  fontSize: V.string().optional(),
+  fontWeight: V.string().optional(),
+  margin: V.string().optional(),
+  padding: V.string().optional()
+});
+const ua = (r) => `styles=${encodeURIComponent(JSON.stringify(r))}`, ut = (r) => {
+  const { subPath: e, styles: t } = r, { contextId: n, dispatchEvent: a, formHeight: s } = Hr(), [o, c] = Ce(""), f = sr(null), l = xt(() => t ? ua(t) : "", [t]), y = xt(() => ({
+    border: "none",
+    width: "100%",
+    height: s,
+    overflow: "hidden"
+  }), [s]), j = xt(() => {
+    const P = new URLSearchParams();
+    return P.append("referer", o), P.append("styles", l), P.append("contextId", n), P.toString();
+  }, [l, n, o]), z = ir(
+    (P) => {
+      !f.current || P.origin == window.location.origin || (P.origin !== et ? console.warn("[form] Ignoring message from unexpected origin:", P, "(expected:", et, ")") : a(P, f.current));
+    },
+    [a]
+  );
+  return Et(() => {
+    if (!(!f.current || !n))
+      return window.addEventListener("message", z), c(window.location.origin), () => window.removeEventListener("message", z);
+  }, [f, n, z]), /* @__PURE__ */ de.jsxDEV(
+    "iframe",
+    {
+      name: `${e}-element`,
+      src: `${et}/app/v1/${e}-element?${j}`,
+      style: y,
+      ref: f
+    },
+    void 0,
+    !1,
+    {
+      fileName: "/home/runner/work/openpay-js-react/openpay-js-react/lib/components/_common/frame.tsx",
+      lineNumber: 64,
+      columnNumber: 5
+    },
+    void 0
+  );
+}, fa = ({ styles: r }) => /* @__PURE__ */ de.jsxDEV(ut, { styles: r, subPath: "card-cvc" }, void 0, !1, {
+  fileName: "/home/runner/work/openpay-js-react/openpay-js-react/lib/components/card-cvc.tsx",
+  lineNumber: 7,
+  columnNumber: 5
+}, void 0), ha = ({ styles: r }) => /* @__PURE__ */ de.jsxDEV(ut, { styles: r, subPath: "card" }, void 0, !1, {
+  fileName: "/home/runner/work/openpay-js-react/openpay-js-react/lib/components/card.tsx",
+  lineNumber: 7,
+  columnNumber: 5
+}, void 0), pa = ({ styles: r }) => /* @__PURE__ */ de.jsxDEV(ut, { styles: r, subPath: "card-expiry" }, void 0, !1, {
+  fileName: "/home/runner/work/openpay-js-react/openpay-js-react/lib/components/card-expiry.tsx",
+  lineNumber: 7,
+  columnNumber: 5
+}, void 0), ma = ({ styles: r }) => /* @__PURE__ */ de.jsxDEV(ut, { styles: r, subPath: "card-number" }, void 0, !1, {
+  fileName: "/home/runner/work/openpay-js-react/openpay-js-react/lib/components/card-number.tsx",
+  lineNumber: 7,
+  columnNumber: 5
+}, void 0);
+export {
+  fa as CardCvcElement,
+  ha as CardElement,
+  pa as CardExpiryElement,
+  ma as CardNumberElement,
+  la as ElementsForm,
+  Hr as useOpenPayElements
+};