dynamic-mui 2.2.0 → 2.3.0

package/dist/signature-14OrZriO.mjs

@@ -0,0 +1,1225 @@
+import { jsxs as rt, jsx as X } from "react/jsx-runtime";
+import Ft, { Component as Yt, useRef as wt, useState as nt, useEffect as Pt } from "react";
+import { g as Lt } from "./index-CddjLTWF.mjs";
+import { Box as Q, Typography as Tt, Button as St, CircularProgress as Bt } from "@mui/material";
+import { u as Nt } from "./s3Upload-dpioZ2c8.mjs";
+function mt() {
+  return mt = Object.assign ? Object.assign.bind() : function(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var n = arguments[r];
+      for (var t in n) ({}).hasOwnProperty.call(n, t) && (e[t] = n[t]);
+    }
+    return e;
+  }, mt.apply(null, arguments);
+}
+function Vt(e, r) {
+  if (e == null) return {};
+  var n = {};
+  for (var t in e) if ({}.hasOwnProperty.call(e, t)) {
+    if (r.indexOf(t) !== -1) continue;
+    n[t] = e[t];
+  }
+  return n;
+}
+function Ht(e, r) {
+  if (e == null) return {};
+  var n, t, o = Vt(e, r);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(e);
+    for (t = 0; t < a.length; t++) n = a[t], r.indexOf(n) === -1 && {}.propertyIsEnumerable.call(e, n) && (o[n] = e[n]);
+  }
+  return o;
+}
+function gt(e) {
+  "@babel/helpers - typeof";
+  return gt = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
+    return typeof r;
+  } : function(r) {
+    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+  }, gt(e);
+}
+function Xt(e, r, n) {
+  return Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function Jt(e, r) {
+  if (!(e instanceof r)) throw new TypeError("Cannot call a class as a function");
+}
+function _t(e, r) {
+  return _t = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, t) {
+    return n.__proto__ = t, n;
+  }, _t(e, r);
+}
+function Gt(e, r) {
+  if (typeof r != "function" && r !== null) throw new TypeError("Super expression must either be null or a function");
+  e.prototype = Object.create(r && r.prototype, {
+    constructor: {
+      value: e,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), r && _t(e, r);
+}
+function st(e) {
+  return st = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(r) {
+    return r.__proto__ || Object.getPrototypeOf(r);
+  }, st(e);
+}
+function zt() {
+  try {
+    var e = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (zt = function() {
+    return !!e;
+  })();
+}
+function Kt(e) {
+  if (e === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function Zt(e, r) {
+  if (r && (gt(r) == "object" || typeof r == "function")) return r;
+  if (r !== void 0) throw new TypeError("Derived constructors may only return object or undefined");
+  return Kt(e);
+}
+function Qt(e) {
+  var r = zt();
+  return function() {
+    var n, t = st(e);
+    if (r) {
+      var o = st(this).constructor;
+      n = Reflect.construct(t, arguments, o);
+    } else n = t.apply(this, arguments);
+    return Zt(this, n);
+  };
+}
+var ot = { exports: {} }, it = { exports: {} }, M = {};
+var Ct;
+function te() {
+  if (Ct) return M;
+  Ct = 1;
+  var e = typeof Symbol == "function" && Symbol.for, r = e ? /* @__PURE__ */ Symbol.for("react.element") : 60103, n = e ? /* @__PURE__ */ Symbol.for("react.portal") : 60106, t = e ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107, o = e ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108, a = e ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114, u = e ? /* @__PURE__ */ Symbol.for("react.provider") : 60109, i = e ? /* @__PURE__ */ Symbol.for("react.context") : 60110, l = e ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111, c = e ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111, f = e ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112, p = e ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113, v = e ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120, m = e ? /* @__PURE__ */ Symbol.for("react.memo") : 60115, E = e ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116, g = e ? /* @__PURE__ */ Symbol.for("react.block") : 60121, b = e ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117, w = e ? /* @__PURE__ */ Symbol.for("react.responder") : 60118, W = e ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
+  function I(d) {
+    if (typeof d == "object" && d !== null) {
+      var Y = d.$$typeof;
+      switch (Y) {
+        case r:
+          switch (d = d.type, d) {
+            case l:
+            case c:
+            case t:
+            case a:
+            case o:
+            case p:
+              return d;
+            default:
+              switch (d = d && d.$$typeof, d) {
+                case i:
+                case f:
+                case E:
+                case m:
+                case u:
+                  return d;
+                default:
+                  return Y;
+              }
+          }
+        case n:
+          return Y;
+      }
+    }
+  }
+  function D(d) {
+    return I(d) === c;
+  }
+  return M.AsyncMode = l, M.ConcurrentMode = c, M.ContextConsumer = i, M.ContextProvider = u, M.Element = r, M.ForwardRef = f, M.Fragment = t, M.Lazy = E, M.Memo = m, M.Portal = n, M.Profiler = a, M.StrictMode = o, M.Suspense = p, M.isAsyncMode = function(d) {
+    return D(d) || I(d) === l;
+  }, M.isConcurrentMode = D, M.isContextConsumer = function(d) {
+    return I(d) === i;
+  }, M.isContextProvider = function(d) {
+    return I(d) === u;
+  }, M.isElement = function(d) {
+    return typeof d == "object" && d !== null && d.$$typeof === r;
+  }, M.isForwardRef = function(d) {
+    return I(d) === f;
+  }, M.isFragment = function(d) {
+    return I(d) === t;
+  }, M.isLazy = function(d) {
+    return I(d) === E;
+  }, M.isMemo = function(d) {
+    return I(d) === m;
+  }, M.isPortal = function(d) {
+    return I(d) === n;
+  }, M.isProfiler = function(d) {
+    return I(d) === a;
+  }, M.isStrictMode = function(d) {
+    return I(d) === o;
+  }, M.isSuspense = function(d) {
+    return I(d) === p;
+  }, M.isValidElementType = function(d) {
+    return typeof d == "string" || typeof d == "function" || d === t || d === c || d === a || d === o || d === p || d === v || typeof d == "object" && d !== null && (d.$$typeof === E || d.$$typeof === m || d.$$typeof === u || d.$$typeof === i || d.$$typeof === f || d.$$typeof === b || d.$$typeof === w || d.$$typeof === W || d.$$typeof === g);
+  }, M.typeOf = I, M;
+}
+var A = {};
+var Ot;
+function ee() {
+  return Ot || (Ot = 1, process.env.NODE_ENV !== "production" && (function() {
+    var e = typeof Symbol == "function" && Symbol.for, r = e ? /* @__PURE__ */ Symbol.for("react.element") : 60103, n = e ? /* @__PURE__ */ Symbol.for("react.portal") : 60106, t = e ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107, o = e ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108, a = e ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114, u = e ? /* @__PURE__ */ Symbol.for("react.provider") : 60109, i = e ? /* @__PURE__ */ Symbol.for("react.context") : 60110, l = e ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111, c = e ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111, f = e ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112, p = e ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113, v = e ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120, m = e ? /* @__PURE__ */ Symbol.for("react.memo") : 60115, E = e ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116, g = e ? /* @__PURE__ */ Symbol.for("react.block") : 60121, b = e ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117, w = e ? /* @__PURE__ */ Symbol.for("react.responder") : 60118, W = e ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
+    function I(h) {
+      return typeof h == "string" || typeof h == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      h === t || h === c || h === a || h === o || h === p || h === v || typeof h == "object" && h !== null && (h.$$typeof === E || h.$$typeof === m || h.$$typeof === u || h.$$typeof === i || h.$$typeof === f || h.$$typeof === b || h.$$typeof === w || h.$$typeof === W || h.$$typeof === g);
+    }
+    function D(h) {
+      if (typeof h == "object" && h !== null) {
+        var F = h.$$typeof;
+        switch (F) {
+          case r:
+            var et = h.type;
+            switch (et) {
+              case l:
+              case c:
+              case t:
+              case a:
+              case o:
+              case p:
+                return et;
+              default:
+                var Et = et && et.$$typeof;
+                switch (Et) {
+                  case i:
+                  case f:
+                  case E:
+                  case m:
+                  case u:
+                    return Et;
+                  default:
+                    return F;
+                }
+            }
+          case n:
+            return F;
+        }
+      }
+    }
+    var d = l, Y = c, N = i, K = u, Z = r, z = f, B = t, U = E, V = m, G = n, ut = a, q = o, H = p, tt = !1;
+    function ft(h) {
+      return tt || (tt = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.")), s(h) || D(h) === l;
+    }
+    function s(h) {
+      return D(h) === c;
+    }
+    function y(h) {
+      return D(h) === i;
+    }
+    function S(h) {
+      return D(h) === u;
+    }
+    function P(h) {
+      return typeof h == "object" && h !== null && h.$$typeof === r;
+    }
+    function _(h) {
+      return D(h) === f;
+    }
+    function C(h) {
+      return D(h) === t;
+    }
+    function x(h) {
+      return D(h) === E;
+    }
+    function T(h) {
+      return D(h) === m;
+    }
+    function O(h) {
+      return D(h) === n;
+    }
+    function j(h) {
+      return D(h) === a;
+    }
+    function R(h) {
+      return D(h) === o;
+    }
+    function $(h) {
+      return D(h) === p;
+    }
+    A.AsyncMode = d, A.ConcurrentMode = Y, A.ContextConsumer = N, A.ContextProvider = K, A.Element = Z, A.ForwardRef = z, A.Fragment = B, A.Lazy = U, A.Memo = V, A.Portal = G, A.Profiler = ut, A.StrictMode = q, A.Suspense = H, A.isAsyncMode = ft, A.isConcurrentMode = s, A.isContextConsumer = y, A.isContextProvider = S, A.isElement = P, A.isForwardRef = _, A.isFragment = C, A.isLazy = x, A.isMemo = T, A.isPortal = O, A.isProfiler = j, A.isStrictMode = R, A.isSuspense = $, A.isValidElementType = I, A.typeOf = D;
+  })()), A;
+}
+var Rt;
+function Ut() {
+  return Rt || (Rt = 1, process.env.NODE_ENV === "production" ? it.exports = te() : it.exports = ee()), it.exports;
+}
+var lt, Mt;
+function re() {
+  if (Mt) return lt;
+  Mt = 1;
+  var e = Object.getOwnPropertySymbols, r = Object.prototype.hasOwnProperty, n = Object.prototype.propertyIsEnumerable;
+  function t(a) {
+    if (a == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(a);
+  }
+  function o() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var a = new String("abc");
+      if (a[5] = "de", Object.getOwnPropertyNames(a)[0] === "5")
+        return !1;
+      for (var u = {}, i = 0; i < 10; i++)
+        u["_" + String.fromCharCode(i)] = i;
+      var l = Object.getOwnPropertyNames(u).map(function(f) {
+        return u[f];
+      });
+      if (l.join("") !== "0123456789")
+        return !1;
+      var c = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(f) {
+        c[f] = f;
+      }), Object.keys(Object.assign({}, c)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return lt = o() ? Object.assign : function(a, u) {
+    for (var i, l = t(a), c, f = 1; f < arguments.length; f++) {
+      i = Object(arguments[f]);
+      for (var p in i)
+        r.call(i, p) && (l[p] = i[p]);
+      if (e) {
+        c = e(i);
+        for (var v = 0; v < c.length; v++)
+          n.call(i, c[v]) && (l[c[v]] = i[c[v]]);
+      }
+    }
+    return l;
+  }, lt;
+}
+var dt, At;
+function bt() {
+  if (At) return dt;
+  At = 1;
+  var e = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return dt = e, dt;
+}
+var ht, Dt;
+function qt() {
+  return Dt || (Dt = 1, ht = Function.call.bind(Object.prototype.hasOwnProperty)), ht;
+}
+var pt, jt;
+function ne() {
+  if (jt) return pt;
+  jt = 1;
+  var e = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var r = /* @__PURE__ */ bt(), n = {}, t = /* @__PURE__ */ qt();
+    e = function(a) {
+      var u = "Warning: " + a;
+      typeof console < "u" && console.error(u);
+      try {
+        throw new Error(u);
+      } catch {
+      }
+    };
+  }
+  function o(a, u, i, l, c) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var f in a)
+        if (t(a, f)) {
+          var p;
+          try {
+            if (typeof a[f] != "function") {
+              var v = Error(
+                (l || "React class") + ": " + i + " type `" + f + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof a[f] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw v.name = "Invariant Violation", v;
+            }
+            p = a[f](u, f, l, i, null, r);
+          } catch (E) {
+            p = E;
+          }
+          if (p && !(p instanceof Error) && e(
+            (l || "React class") + ": type specification of " + i + " `" + f + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof p + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), p instanceof Error && !(p.message in n)) {
+            n[p.message] = !0;
+            var m = c ? c() : "";
+            e(
+              "Failed " + i + " type: " + p.message + (m ?? "")
+            );
+          }
+        }
+    }
+  }
+  return o.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (n = {});
+  }, pt = o, pt;
+}
+var vt, It;
+function oe() {
+  if (It) return vt;
+  It = 1;
+  var e = Ut(), r = re(), n = /* @__PURE__ */ bt(), t = /* @__PURE__ */ qt(), o = /* @__PURE__ */ ne(), a = function() {
+  };
+  process.env.NODE_ENV !== "production" && (a = function(i) {
+    var l = "Warning: " + i;
+    typeof console < "u" && console.error(l);
+    try {
+      throw new Error(l);
+    } catch {
+    }
+  });
+  function u() {
+    return null;
+  }
+  return vt = function(i, l) {
+    var c = typeof Symbol == "function" && Symbol.iterator, f = "@@iterator";
+    function p(s) {
+      var y = s && (c && s[c] || s[f]);
+      if (typeof y == "function")
+        return y;
+    }
+    var v = "<<anonymous>>", m = {
+      array: w("array"),
+      bigint: w("bigint"),
+      bool: w("boolean"),
+      func: w("function"),
+      number: w("number"),
+      object: w("object"),
+      string: w("string"),
+      symbol: w("symbol"),
+      any: W(),
+      arrayOf: I,
+      element: D(),
+      elementType: d(),
+      instanceOf: Y,
+      node: z(),
+      objectOf: K,
+      oneOf: N,
+      oneOfType: Z,
+      shape: U,
+      exact: V
+    };
+    function E(s, y) {
+      return s === y ? s !== 0 || 1 / s === 1 / y : s !== s && y !== y;
+    }
+    function g(s, y) {
+      this.message = s, this.data = y && typeof y == "object" ? y : {}, this.stack = "";
+    }
+    g.prototype = Error.prototype;
+    function b(s) {
+      if (process.env.NODE_ENV !== "production")
+        var y = {}, S = 0;
+      function P(C, x, T, O, j, R, $) {
+        if (O = O || v, R = R || T, $ !== n) {
+          if (l) {
+            var h = new Error(
+              "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+            );
+            throw h.name = "Invariant Violation", h;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var F = O + ":" + T;
+            !y[F] && // Avoid spamming the console because they are often not actionable except for lib authors
+            S < 3 && (a(
+              "You are manually calling a React.PropTypes validation function for the `" + R + "` prop on `" + O + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), y[F] = !0, S++);
+          }
+        }
+        return x[T] == null ? C ? x[T] === null ? new g("The " + j + " `" + R + "` is marked as required " + ("in `" + O + "`, but its value is `null`.")) : new g("The " + j + " `" + R + "` is marked as required in " + ("`" + O + "`, but its value is `undefined`.")) : null : s(x, T, O, j, R);
+      }
+      var _ = P.bind(null, !1);
+      return _.isRequired = P.bind(null, !0), _;
+    }
+    function w(s) {
+      function y(S, P, _, C, x, T) {
+        var O = S[P], j = q(O);
+        if (j !== s) {
+          var R = H(O);
+          return new g(
+            "Invalid " + C + " `" + x + "` of type " + ("`" + R + "` supplied to `" + _ + "`, expected ") + ("`" + s + "`."),
+            { expectedType: s }
+          );
+        }
+        return null;
+      }
+      return b(y);
+    }
+    function W() {
+      return b(u);
+    }
+    function I(s) {
+      function y(S, P, _, C, x) {
+        if (typeof s != "function")
+          return new g("Property `" + x + "` of component `" + _ + "` has invalid PropType notation inside arrayOf.");
+        var T = S[P];
+        if (!Array.isArray(T)) {
+          var O = q(T);
+          return new g("Invalid " + C + " `" + x + "` of type " + ("`" + O + "` supplied to `" + _ + "`, expected an array."));
+        }
+        for (var j = 0; j < T.length; j++) {
+          var R = s(T, j, _, C, x + "[" + j + "]", n);
+          if (R instanceof Error)
+            return R;
+        }
+        return null;
+      }
+      return b(y);
+    }
+    function D() {
+      function s(y, S, P, _, C) {
+        var x = y[S];
+        if (!i(x)) {
+          var T = q(x);
+          return new g("Invalid " + _ + " `" + C + "` of type " + ("`" + T + "` supplied to `" + P + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return b(s);
+    }
+    function d() {
+      function s(y, S, P, _, C) {
+        var x = y[S];
+        if (!e.isValidElementType(x)) {
+          var T = q(x);
+          return new g("Invalid " + _ + " `" + C + "` of type " + ("`" + T + "` supplied to `" + P + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return b(s);
+    }
+    function Y(s) {
+      function y(S, P, _, C, x) {
+        if (!(S[P] instanceof s)) {
+          var T = s.name || v, O = ft(S[P]);
+          return new g("Invalid " + C + " `" + x + "` of type " + ("`" + O + "` supplied to `" + _ + "`, expected ") + ("instance of `" + T + "`."));
+        }
+        return null;
+      }
+      return b(y);
+    }
+    function N(s) {
+      if (!Array.isArray(s))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? a(
+          "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+        ) : a("Invalid argument supplied to oneOf, expected an array.")), u;
+      function y(S, P, _, C, x) {
+        for (var T = S[P], O = 0; O < s.length; O++)
+          if (E(T, s[O]))
+            return null;
+        var j = JSON.stringify(s, function($, h) {
+          var F = H(h);
+          return F === "symbol" ? String(h) : h;
+        });
+        return new g("Invalid " + C + " `" + x + "` of value `" + String(T) + "` " + ("supplied to `" + _ + "`, expected one of " + j + "."));
+      }
+      return b(y);
+    }
+    function K(s) {
+      function y(S, P, _, C, x) {
+        if (typeof s != "function")
+          return new g("Property `" + x + "` of component `" + _ + "` has invalid PropType notation inside objectOf.");
+        var T = S[P], O = q(T);
+        if (O !== "object")
+          return new g("Invalid " + C + " `" + x + "` of type " + ("`" + O + "` supplied to `" + _ + "`, expected an object."));
+        for (var j in T)
+          if (t(T, j)) {
+            var R = s(T, j, _, C, x + "." + j, n);
+            if (R instanceof Error)
+              return R;
+          }
+        return null;
+      }
+      return b(y);
+    }
+    function Z(s) {
+      if (!Array.isArray(s))
+        return process.env.NODE_ENV !== "production" && a("Invalid argument supplied to oneOfType, expected an instance of array."), u;
+      for (var y = 0; y < s.length; y++) {
+        var S = s[y];
+        if (typeof S != "function")
+          return a(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + tt(S) + " at index " + y + "."
+          ), u;
+      }
+      function P(_, C, x, T, O) {
+        for (var j = [], R = 0; R < s.length; R++) {
+          var $ = s[R], h = $(_, C, x, T, O, n);
+          if (h == null)
+            return null;
+          h.data && t(h.data, "expectedType") && j.push(h.data.expectedType);
+        }
+        var F = j.length > 0 ? ", expected one of type [" + j.join(", ") + "]" : "";
+        return new g("Invalid " + T + " `" + O + "` supplied to " + ("`" + x + "`" + F + "."));
+      }
+      return b(P);
+    }
+    function z() {
+      function s(y, S, P, _, C) {
+        return G(y[S]) ? null : new g("Invalid " + _ + " `" + C + "` supplied to " + ("`" + P + "`, expected a ReactNode."));
+      }
+      return b(s);
+    }
+    function B(s, y, S, P, _) {
+      return new g(
+        (s || "React class") + ": " + y + " type `" + S + "." + P + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + _ + "`."
+      );
+    }
+    function U(s) {
+      function y(S, P, _, C, x) {
+        var T = S[P], O = q(T);
+        if (O !== "object")
+          return new g("Invalid " + C + " `" + x + "` of type `" + O + "` " + ("supplied to `" + _ + "`, expected `object`."));
+        for (var j in s) {
+          var R = s[j];
+          if (typeof R != "function")
+            return B(_, C, x, j, H(R));
+          var $ = R(T, j, _, C, x + "." + j, n);
+          if ($)
+            return $;
+        }
+        return null;
+      }
+      return b(y);
+    }
+    function V(s) {
+      function y(S, P, _, C, x) {
+        var T = S[P], O = q(T);
+        if (O !== "object")
+          return new g("Invalid " + C + " `" + x + "` of type `" + O + "` " + ("supplied to `" + _ + "`, expected `object`."));
+        var j = r({}, S[P], s);
+        for (var R in j) {
+          var $ = s[R];
+          if (t(s, R) && typeof $ != "function")
+            return B(_, C, x, R, H($));
+          if (!$)
+            return new g(
+              "Invalid " + C + " `" + x + "` key `" + R + "` supplied to `" + _ + "`.\nBad object: " + JSON.stringify(S[P], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(s), null, "  ")
+            );
+          var h = $(T, R, _, C, x + "." + R, n);
+          if (h)
+            return h;
+        }
+        return null;
+      }
+      return b(y);
+    }
+    function G(s) {
+      switch (typeof s) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !s;
+        case "object":
+          if (Array.isArray(s))
+            return s.every(G);
+          if (s === null || i(s))
+            return !0;
+          var y = p(s);
+          if (y) {
+            var S = y.call(s), P;
+            if (y !== s.entries) {
+              for (; !(P = S.next()).done; )
+                if (!G(P.value))
+                  return !1;
+            } else
+              for (; !(P = S.next()).done; ) {
+                var _ = P.value;
+                if (_ && !G(_[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function ut(s, y) {
+      return s === "symbol" ? !0 : y ? y["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && y instanceof Symbol : !1;
+    }
+    function q(s) {
+      var y = typeof s;
+      return Array.isArray(s) ? "array" : s instanceof RegExp ? "object" : ut(y, s) ? "symbol" : y;
+    }
+    function H(s) {
+      if (typeof s > "u" || s === null)
+        return "" + s;
+      var y = q(s);
+      if (y === "object") {
+        if (s instanceof Date)
+          return "date";
+        if (s instanceof RegExp)
+          return "regexp";
+      }
+      return y;
+    }
+    function tt(s) {
+      var y = H(s);
+      switch (y) {
+        case "array":
+        case "object":
+          return "an " + y;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + y;
+        default:
+          return y;
+      }
+    }
+    function ft(s) {
+      return !s.constructor || !s.constructor.name ? v : s.constructor.name;
+    }
+    return m.checkPropTypes = o, m.resetWarningCache = o.resetWarningCache, m.PropTypes = m, m;
+  }, vt;
+}
+var yt, kt;
+function ie() {
+  if (kt) return yt;
+  kt = 1;
+  var e = /* @__PURE__ */ bt();
+  function r() {
+  }
+  function n() {
+  }
+  return n.resetWarningCache = r, yt = function() {
+    function t(u, i, l, c, f, p) {
+      if (p !== e) {
+        var v = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw v.name = "Invariant Violation", v;
+      }
+    }
+    t.isRequired = t;
+    function o() {
+      return t;
+    }
+    var a = {
+      array: t,
+      bigint: t,
+      bool: t,
+      func: t,
+      number: t,
+      object: t,
+      string: t,
+      symbol: t,
+      any: t,
+      arrayOf: o,
+      element: t,
+      elementType: t,
+      instanceOf: o,
+      node: t,
+      objectOf: o,
+      oneOf: o,
+      oneOfType: o,
+      shape: o,
+      exact: o,
+      checkPropTypes: n,
+      resetWarningCache: r
+    };
+    return a.PropTypes = a, a;
+  }, yt;
+}
+var Wt;
+function ae() {
+  if (Wt) return ot.exports;
+  if (Wt = 1, process.env.NODE_ENV !== "production") {
+    var e = Ut(), r = !0;
+    ot.exports = /* @__PURE__ */ oe()(e.isElement, r);
+  } else
+    ot.exports = /* @__PURE__ */ ie()();
+  return ot.exports;
+}
+var se = /* @__PURE__ */ ae();
+const L = /* @__PURE__ */ Lt(se);
+function J(e, r, n) {
+  this.x = e, this.y = r, this.time = n || (/* @__PURE__ */ new Date()).getTime();
+}
+J.prototype.velocityFrom = function(e) {
+  return this.time !== e.time ? this.distanceTo(e) / (this.time - e.time) : 1;
+};
+J.prototype.distanceTo = function(e) {
+  return Math.sqrt(Math.pow(this.x - e.x, 2) + Math.pow(this.y - e.y, 2));
+};
+J.prototype.equals = function(e) {
+  return this.x === e.x && this.y === e.y && this.time === e.time;
+};
+function xt(e, r, n, t) {
+  this.startPoint = e, this.control1 = r, this.control2 = n, this.endPoint = t;
+}
+xt.prototype.length = function() {
+  for (var e = 10, r = 0, n = void 0, t = void 0, o = 0; o <= e; o += 1) {
+    var a = o / e, u = this._point(a, this.startPoint.x, this.control1.x, this.control2.x, this.endPoint.x), i = this._point(a, this.startPoint.y, this.control1.y, this.control2.y, this.endPoint.y);
+    if (o > 0) {
+      var l = u - n, c = i - t;
+      r += Math.sqrt(l * l + c * c);
+    }
+    n = u, t = i;
+  }
+  return r;
+};
+xt.prototype._point = function(e, r, n, t, o) {
+  return r * (1 - e) * (1 - e) * (1 - e) + 3 * n * (1 - e) * (1 - e) * e + 3 * t * (1 - e) * e * e + o * e * e * e;
+};
+function ce(e, r, n) {
+  var t, o, a, u = null, i = 0;
+  n || (n = {});
+  var l = function() {
+    i = n.leading === !1 ? 0 : Date.now(), u = null, a = e.apply(t, o), u || (t = o = null);
+  };
+  return function() {
+    var c = Date.now();
+    !i && n.leading === !1 && (i = c);
+    var f = r - (c - i);
+    return t = this, o = arguments, f <= 0 || f > r ? (u && (clearTimeout(u), u = null), i = c, a = e.apply(t, o), u || (t = o = null)) : !u && n.trailing !== !1 && (u = setTimeout(l, f)), a;
+  };
+}
+function k(e, r) {
+  var n = this, t = r || {};
+  this.velocityFilterWeight = t.velocityFilterWeight || 0.7, this.minWidth = t.minWidth || 0.5, this.maxWidth = t.maxWidth || 2.5, this.throttle = "throttle" in t ? t.throttle : 16, this.minDistance = "minDistance" in t ? t.minDistance : 5, this.throttle ? this._strokeMoveUpdate = ce(k.prototype._strokeUpdate, this.throttle) : this._strokeMoveUpdate = k.prototype._strokeUpdate, this.dotSize = t.dotSize || function() {
+    return (this.minWidth + this.maxWidth) / 2;
+  }, this.penColor = t.penColor || "black", this.backgroundColor = t.backgroundColor || "rgba(0,0,0,0)", this.onBegin = t.onBegin, this.onEnd = t.onEnd, this._canvas = e, this._ctx = e.getContext("2d"), this.clear(), this._handleMouseDown = function(o) {
+    o.which === 1 && (n._mouseButtonDown = !0, n._strokeBegin(o));
+  }, this._handleMouseMove = function(o) {
+    n._mouseButtonDown && n._strokeMoveUpdate(o);
+  }, this._handleMouseUp = function(o) {
+    o.which === 1 && n._mouseButtonDown && (n._mouseButtonDown = !1, n._strokeEnd(o));
+  }, this._handleTouchStart = function(o) {
+    if (o.targetTouches.length === 1) {
+      var a = o.changedTouches[0];
+      n._strokeBegin(a);
+    }
+  }, this._handleTouchMove = function(o) {
+    o.preventDefault();
+    var a = o.targetTouches[0];
+    n._strokeMoveUpdate(a);
+  }, this._handleTouchEnd = function(o) {
+    var a = o.target === n._canvas;
+    a && (o.preventDefault(), n._strokeEnd(o));
+  }, this.on();
+}
+k.prototype.clear = function() {
+  var e = this._ctx, r = this._canvas;
+  e.fillStyle = this.backgroundColor, e.clearRect(0, 0, r.width, r.height), e.fillRect(0, 0, r.width, r.height), this._data = [], this._reset(), this._isEmpty = !0;
+};
+k.prototype.fromDataURL = function(e) {
+  var r = this, n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, t = new Image(), o = n.ratio || window.devicePixelRatio || 1, a = n.width || this._canvas.width / o, u = n.height || this._canvas.height / o;
+  this._reset(), t.src = e, t.onload = function() {
+    r._ctx.drawImage(t, 0, 0, a, u);
+  }, this._isEmpty = !1;
+};
+k.prototype.toDataURL = function(e) {
+  var r;
+  switch (e) {
+    case "image/svg+xml":
+      return this._toSVG();
+    default:
+      for (var n = arguments.length, t = Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+        t[o - 1] = arguments[o];
+      return (r = this._canvas).toDataURL.apply(r, [e].concat(t));
+  }
+};
+k.prototype.on = function() {
+  this._handleMouseEvents(), this._handleTouchEvents();
+};
+k.prototype.off = function() {
+  this._canvas.removeEventListener("mousedown", this._handleMouseDown), this._canvas.removeEventListener("mousemove", this._handleMouseMove), document.removeEventListener("mouseup", this._handleMouseUp), this._canvas.removeEventListener("touchstart", this._handleTouchStart), this._canvas.removeEventListener("touchmove", this._handleTouchMove), this._canvas.removeEventListener("touchend", this._handleTouchEnd);
+};
+k.prototype.isEmpty = function() {
+  return this._isEmpty;
+};
+k.prototype._strokeBegin = function(e) {
+  this._data.push([]), this._reset(), this._strokeUpdate(e), typeof this.onBegin == "function" && this.onBegin(e);
+};
+k.prototype._strokeUpdate = function(e) {
+  var r = e.clientX, n = e.clientY, t = this._createPoint(r, n), o = this._data[this._data.length - 1], a = o && o[o.length - 1], u = a && t.distanceTo(a) < this.minDistance;
+  if (!(a && u)) {
+    var i = this._addPoint(t), l = i.curve, c = i.widths;
+    l && c && this._drawCurve(l, c.start, c.end), this._data[this._data.length - 1].push({
+      x: t.x,
+      y: t.y,
+      time: t.time,
+      color: this.penColor
+    });
+  }
+};
+k.prototype._strokeEnd = function(e) {
+  var r = this.points.length > 2, n = this.points[0];
+  if (!r && n && this._drawDot(n), n) {
+    var t = this._data[this._data.length - 1], o = t[t.length - 1];
+    n.equals(o) || t.push({
+      x: n.x,
+      y: n.y,
+      time: n.time,
+      color: this.penColor
+    });
+  }
+  typeof this.onEnd == "function" && this.onEnd(e);
+};
+k.prototype._handleMouseEvents = function() {
+  this._mouseButtonDown = !1, this._canvas.addEventListener("mousedown", this._handleMouseDown), this._canvas.addEventListener("mousemove", this._handleMouseMove), document.addEventListener("mouseup", this._handleMouseUp);
+};
+k.prototype._handleTouchEvents = function() {
+  this._canvas.style.msTouchAction = "none", this._canvas.style.touchAction = "none", this._canvas.addEventListener("touchstart", this._handleTouchStart), this._canvas.addEventListener("touchmove", this._handleTouchMove), this._canvas.addEventListener("touchend", this._handleTouchEnd);
+};
+k.prototype._reset = function() {
+  this.points = [], this._lastVelocity = 0, this._lastWidth = (this.minWidth + this.maxWidth) / 2, this._ctx.fillStyle = this.penColor;
+};
+k.prototype._createPoint = function(e, r, n) {
+  var t = this._canvas.getBoundingClientRect();
+  return new J(e - t.left, r - t.top, n || (/* @__PURE__ */ new Date()).getTime());
+};
+k.prototype._addPoint = function(e) {
+  var r = this.points, n = void 0;
+  if (r.push(e), r.length > 2) {
+    r.length === 3 && r.unshift(r[0]), n = this._calculateCurveControlPoints(r[0], r[1], r[2]);
+    var t = n.c2;
+    n = this._calculateCurveControlPoints(r[1], r[2], r[3]);
+    var o = n.c1, a = new xt(r[1], t, o, r[2]), u = this._calculateCurveWidths(a);
+    return r.shift(), { curve: a, widths: u };
+  }
+  return {};
+};
+k.prototype._calculateCurveControlPoints = function(e, r, n) {
+  var t = e.x - r.x, o = e.y - r.y, a = r.x - n.x, u = r.y - n.y, i = { x: (e.x + r.x) / 2, y: (e.y + r.y) / 2 }, l = { x: (r.x + n.x) / 2, y: (r.y + n.y) / 2 }, c = Math.sqrt(t * t + o * o), f = Math.sqrt(a * a + u * u), p = i.x - l.x, v = i.y - l.y, m = f / (c + f), E = { x: l.x + p * m, y: l.y + v * m }, g = r.x - E.x, b = r.y - E.y;
+  return {
+    c1: new J(i.x + g, i.y + b),
+    c2: new J(l.x + g, l.y + b)
+  };
+};
+k.prototype._calculateCurveWidths = function(e) {
+  var r = e.startPoint, n = e.endPoint, t = { start: null, end: null }, o = this.velocityFilterWeight * n.velocityFrom(r) + (1 - this.velocityFilterWeight) * this._lastVelocity, a = this._strokeWidth(o);
+  return t.start = this._lastWidth, t.end = a, this._lastVelocity = o, this._lastWidth = a, t;
+};
+k.prototype._strokeWidth = function(e) {
+  return Math.max(this.maxWidth / (e + 1), this.minWidth);
+};
+k.prototype._drawPoint = function(e, r, n) {
+  var t = this._ctx;
+  t.moveTo(e, r), t.arc(e, r, n, 0, 2 * Math.PI, !1), this._isEmpty = !1;
+};
+k.prototype._drawCurve = function(e, r, n) {
+  var t = this._ctx, o = n - r, a = Math.floor(e.length());
+  t.beginPath();
+  for (var u = 0; u < a; u += 1) {
+    var i = u / a, l = i * i, c = l * i, f = 1 - i, p = f * f, v = p * f, m = v * e.startPoint.x;
+    m += 3 * p * i * e.control1.x, m += 3 * f * l * e.control2.x, m += c * e.endPoint.x;
+    var E = v * e.startPoint.y;
+    E += 3 * p * i * e.control1.y, E += 3 * f * l * e.control2.y, E += c * e.endPoint.y;
+    var g = r + c * o;
+    this._drawPoint(m, E, g);
+  }
+  t.closePath(), t.fill();
+};
+k.prototype._drawDot = function(e) {
+  var r = this._ctx, n = typeof this.dotSize == "function" ? this.dotSize() : this.dotSize;
+  r.beginPath(), this._drawPoint(e.x, e.y, n), r.closePath(), r.fill();
+};
+k.prototype._fromData = function(e, r, n) {
+  for (var t = 0; t < e.length; t += 1) {
+    var o = e[t];
+    if (o.length > 1)
+      for (var a = 0; a < o.length; a += 1) {
+        var u = o[a], i = new J(u.x, u.y, u.time), l = u.color;
+        if (a === 0)
+          this.penColor = l, this._reset(), this._addPoint(i);
+        else if (a !== o.length - 1) {
+          var c = this._addPoint(i), f = c.curve, p = c.widths;
+          f && p && r(f, p, l);
+        }
+      }
+    else {
+      this._reset();
+      var v = o[0];
+      n(v);
+    }
+  }
+};
+k.prototype._toSVG = function() {
+  var e = this, r = this._data, n = this._canvas, t = Math.max(window.devicePixelRatio || 1, 1), o = 0, a = 0, u = n.width / t, i = n.height / t, l = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  l.setAttributeNS(null, "width", n.width), l.setAttributeNS(null, "height", n.height), this._fromData(r, function(w, W, I) {
+    var D = document.createElement("path");
+    if (!isNaN(w.control1.x) && !isNaN(w.control1.y) && !isNaN(w.control2.x) && !isNaN(w.control2.y)) {
+      var d = "M " + w.startPoint.x.toFixed(3) + "," + w.startPoint.y.toFixed(3) + " " + ("C " + w.control1.x.toFixed(3) + "," + w.control1.y.toFixed(3) + " ") + (w.control2.x.toFixed(3) + "," + w.control2.y.toFixed(3) + " ") + (w.endPoint.x.toFixed(3) + "," + w.endPoint.y.toFixed(3));
+      D.setAttribute("d", d), D.setAttribute("stroke-width", (W.end * 2.25).toFixed(3)), D.setAttribute("stroke", I), D.setAttribute("fill", "none"), D.setAttribute("stroke-linecap", "round"), l.appendChild(D);
+    }
+  }, function(w) {
+    var W = document.createElement("circle"), I = typeof e.dotSize == "function" ? e.dotSize() : e.dotSize;
+    W.setAttribute("r", I), W.setAttribute("cx", w.x), W.setAttribute("cy", w.y), W.setAttribute("fill", w.color), l.appendChild(W);
+  });
+  var c = "data:image/svg+xml;base64,", f = '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"' + (' viewBox="' + o + " " + a + " " + u + " " + i + '"') + (' width="' + u + '"') + (' height="' + i + '"') + ">", p = l.innerHTML;
+  if (p === void 0) {
+    var v = document.createElement("dummy"), m = l.childNodes;
+    v.innerHTML = "";
+    for (var E = 0; E < m.length; E += 1)
+      v.appendChild(m[E].cloneNode(!0));
+    p = v.innerHTML;
+  }
+  var g = "</svg>", b = f + p + g;
+  return c + btoa(b);
+};
+k.prototype.fromData = function(e) {
+  var r = this;
+  this.clear(), this._fromData(e, function(n, t) {
+    return r._drawCurve(n, t.start, t.end);
+  }, function(n) {
+    return r._drawDot(n);
+  }), this._data = e;
+};
+k.prototype.toData = function() {
+  return this._data;
+};
+var at = { exports: {} }, ue = at.exports, $t;
+function fe() {
+  return $t || ($t = 1, (function(e, r) {
+    (function(n, t) {
+      e.exports = t();
+    })(ue, function() {
+      return (function(n) {
+        function t(a) {
+          if (o[a]) return o[a].exports;
+          var u = o[a] = { exports: {}, id: a, loaded: !1 };
+          return n[a].call(u.exports, u, u.exports, t), u.loaded = !0, u.exports;
+        }
+        var o = {};
+        return t.m = n, t.c = o, t.p = "", t(0);
+      })([function(n, t) {
+        function o(c) {
+          var f = c.getContext("2d"), p = c.width, v = c.height, m = f.getImageData(0, 0, p, v).data, E = i(!0, p, v, m), g = i(!1, p, v, m), b = l(!0, p, v, m), w = l(!1, p, v, m), W = w - b + 1, I = g - E + 1, D = f.getImageData(b, E, W, I);
+          return c.width = W, c.height = I, f.clearRect(0, 0, W, I), f.putImageData(D, 0, 0), c;
+        }
+        function a(c, f, p, v) {
+          return { red: v[4 * (p * f + c)], green: v[4 * (p * f + c) + 1], blue: v[4 * (p * f + c) + 2], alpha: v[4 * (p * f + c) + 3] };
+        }
+        function u(c, f, p, v) {
+          return a(c, f, p, v).alpha;
+        }
+        function i(c, f, p, v) {
+          for (var m = c ? 1 : -1, E = c ? 0 : p - 1, g = E; c ? g < p : g > -1; g += m) for (var b = 0; b < f; b++) if (u(b, g, f, v)) return g;
+          return null;
+        }
+        function l(c, f, p, v) {
+          for (var m = c ? 1 : -1, E = c ? 0 : f - 1, g = E; c ? g < f : g > -1; g += m) for (var b = 0; b < p; b++) if (u(g, b, f, v)) return g;
+          return null;
+        }
+        Object.defineProperty(t, "__esModule", { value: !0 }), t.default = o;
+      }]);
+    });
+  })(at)), at.exports;
+}
+var le = fe();
+const de = /* @__PURE__ */ Lt(le);
+var he = ["canvasProps", "clearOnResize"], ct = /* @__PURE__ */ (function(e) {
+  Gt(n, e);
+  var r = Qt(n);
+  function n() {
+    var t;
+    Jt(this, n);
+    for (var o = arguments.length, a = new Array(o), u = 0; u < o; u++)
+      a[u] = arguments[u];
+    return t = r.call.apply(r, [this].concat(a)), t.staticThis = t.constructor, t._sigPad = null, t._canvas = null, t.setRef = function(i) {
+      t._canvas = i, t._canvas === null && (t._sigPad = null);
+    }, t._excludeOurProps = function() {
+      var i = t.props;
+      i.canvasProps, i.clearOnResize;
+      var l = Ht(i, he);
+      return l;
+    }, t.componentDidMount = function() {
+      var i = t.getCanvas();
+      t._sigPad = new k(i, t._excludeOurProps()), t._resizeCanvas(), t.on();
+    }, t.componentWillUnmount = function() {
+      t.off();
+    }, t.componentDidUpdate = function() {
+      Object.assign(t._sigPad, t._excludeOurProps());
+    }, t.getCanvas = function() {
+      if (t._canvas === null)
+        throw t.staticThis.refNullError;
+      return t._canvas;
+    }, t.getTrimmedCanvas = function() {
+      var i = t.getCanvas(), l = document.createElement("canvas");
+      return l.width = i.width, l.height = i.height, l.getContext("2d").drawImage(i, 0, 0), de(l);
+    }, t.getSignaturePad = function() {
+      if (t._sigPad === null)
+        throw t.staticThis.refNullError;
+      return t._sigPad;
+    }, t._checkClearOnResize = function() {
+      t.props.clearOnResize && t._resizeCanvas();
+    }, t._resizeCanvas = function() {
+      var i, l, c = (i = t.props.canvasProps) !== null && i !== void 0 ? i : {}, f = c.width, p = c.height;
+      if (!(typeof f < "u" && typeof p < "u")) {
+        var v = t.getCanvas(), m = Math.max((l = window.devicePixelRatio) !== null && l !== void 0 ? l : 1, 1);
+        typeof f > "u" && (v.width = v.offsetWidth * m), typeof p > "u" && (v.height = v.offsetHeight * m), v.getContext("2d").scale(m, m), t.clear();
+      }
+    }, t.render = function() {
+      var i = t.props.canvasProps;
+      return /* @__PURE__ */ Ft.createElement("canvas", mt({
+        ref: t.setRef
+      }, i));
+    }, t.on = function() {
+      return window.addEventListener("resize", t._checkClearOnResize), t.getSignaturePad().on();
+    }, t.off = function() {
+      return window.removeEventListener("resize", t._checkClearOnResize), t.getSignaturePad().off();
+    }, t.clear = function() {
+      return t.getSignaturePad().clear();
+    }, t.isEmpty = function() {
+      return t.getSignaturePad().isEmpty();
+    }, t.fromDataURL = function(i, l) {
+      return t.getSignaturePad().fromDataURL(i, l);
+    }, t.toDataURL = function(i, l) {
+      return t.getSignaturePad().toDataURL(i, l);
+    }, t.fromData = function(i) {
+      return t.getSignaturePad().fromData(i);
+    }, t.toData = function() {
+      return t.getSignaturePad().toData();
+    }, t;
+  }
+  return Xt(n);
+})(Yt);
+ct.propTypes = {
+  // signature_pad's props
+  velocityFilterWeight: L.number,
+  minWidth: L.number,
+  maxWidth: L.number,
+  minDistance: L.number,
+  dotSize: L.oneOfType([L.number, L.func]),
+  penColor: L.string,
+  throttle: L.number,
+  onEnd: L.func,
+  onBegin: L.func,
+  // props specific to the React wrapper
+  canvasProps: L.object,
+  clearOnResize: L.bool
+};
+ct.defaultProps = {
+  clearOnResize: !0
+};
+ct.refNullError = new Error("react-signature-canvas is currently mounting or unmounting: React refs are null during this phase.");
+function _e({ attributes: e = {}, rules: r = {}, onChange: n }) {
+  const { id: t = "", MuiAttributes: o = {}, label: a = "Signature", bucket: u = "", region: i = "", identityPoolId: l = "", path: c = "", disabled: f = !1, CanvasProps: p = {} } = e, v = wt(null), m = wt(null), [E, g] = nt(!1), [b, w] = nt(e.value || null), [W, I] = nt(400), [D, d] = nt(!1), Y = r?.validation?.some((z) => z.rule === "mandatory") || !1, N = p?.style?.height || 150;
+  Pt(() => {
+    const z = m.current;
+    if (!z) return;
+    const B = new ResizeObserver((U) => {
+      const V = U[0]?.contentRect?.width;
+      V && V > 0 && I(Math.floor(V));
+    });
+    return B.observe(z), () => B.disconnect();
+  }, []), Pt(() => {
+    if (!e.value) {
+      w(null), d(!1), v.current && v.current.clear();
+      return;
+    }
+    w(e.value);
+  }, [e.value]);
+  const K = () => {
+    v.current && v.current.clear(), w(null), d(!1), n && n({ id: t, value: "" });
+  }, Z = async () => {
+    if (!v.current || v.current.isEmpty()) return;
+    g(!0);
+    const z = v.current.toDataURL("image/png"), B = `${t}-${Date.now()}.png`;
+    try {
+      const U = await Nt(z, B, u, i, l, c);
+      w(U), d(!0), n && n({ id: t, value: U });
+    } catch (U) {
+      console.error("Signature upload failed", U);
+    } finally {
+      g(!1);
+    }
+  };
+  return /* @__PURE__ */ rt(Q, { sx: { width: "100%", ...o.sx }, children: [
+    /* @__PURE__ */ rt(Tt, { variant: "subtitle2", gutterBottom: !0, sx: { display: "flex" }, children: [
+      a,
+      Y && /* @__PURE__ */ X(Q, { component: "span", sx: { color: "error.main", ml: 0.5 }, children: "*" })
+    ] }),
+    /* @__PURE__ */ rt(
+      Q,
+      {
+        ref: m,
+        sx: {
+          position: "relative",
+          // Own stacking context so neighbouring fields can never paint
+          // over the drawing surface and steal pointer events.
+          isolation: "isolate",
+          zIndex: 1,
+          border: "1px solid",
+          borderColor: "divider",
+          borderRadius: 1,
+          overflow: "hidden",
+          bgcolor: "background.paper"
+        },
+        children: [
+          /* @__PURE__ */ X(
+            ct,
+            {
+              ref: v,
+              penColor: "black",
+              canvasProps: {
+                className: "sigCanvas",
+                width: W,
+                height: N,
+                style: {
+                  display: "block",
+                  position: "relative",
+                  zIndex: 1,
+                  // Prevent the browser from treating a signing drag as a
+                  // scroll/pan gesture (touch & stylus) — without this,
+                  // strokes are swallowed whenever the page can scroll,
+                  // which is exactly when other fields are present.
+                  touchAction: "none",
+                  pointerEvents: f ? "none" : "auto",
+                  ...p?.style,
+                  width: "100%",
+                  height: N
+                }
+              },
+              backgroundColor: "transparent"
+            }
+          ),
+          b && /* @__PURE__ */ X(
+            Q,
+            {
+              component: "img",
+              src: b,
+              alt: "Signature",
+              sx: {
+                position: "absolute",
+                inset: 0,
+                width: "100%",
+                height: N,
+                objectFit: "contain",
+                bgcolor: "background.paper"
+              }
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ rt(Q, { sx: { display: "flex", flexWrap: "wrap", gap: 1, alignItems: "center", mt: 1 }, children: [
+      /* @__PURE__ */ X(St, { variant: "outlined", color: "secondary", onClick: K, size: "small", disabled: f || E, children: "Clear" }),
+      /* @__PURE__ */ X(
+        St,
+        {
+          variant: "contained",
+          color: "primary",
+          onClick: Z,
+          size: "small",
+          disabled: f || E || b !== null,
+          startIcon: E ? /* @__PURE__ */ X(Bt, { size: 16, color: "inherit" }) : null,
+          children: b ? "Saved" : "Save"
+        }
+      ),
+      D && b && /* @__PURE__ */ X(Tt, { variant: "caption", color: "success.main", children: "Signature Saved!" })
+    ] })
+  ] });
+}
+export {
+  _e as default
+};