@frigate-nvr/image-annotator 1.0.0

package/dist/components/BoundingBox.js

@@ -0,0 +1,2553 @@
+import { jsxs as Xe, jsx as he } from "react/jsx-runtime";
+import * as pe from "react";
+import ft, { createElement as qe, PureComponent as Pt, useState as Rt } from "react";
+import { a as _t, g as Dt } from "../_commonjsHelpers-DjF3Plf2.js";
+import ct, { flushSync as Tt } from "react-dom";
+import { u as Ct } from "../index.esm-FeyXGhGs.js";
+var Pe = { exports: {} }, ht = {}, je = { exports: {} }, be = { exports: {} }, N = {};
+/** @license React v16.13.1
+ * react-is.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 Ge;
+function Ot() {
+  if (Ge) return N;
+  Ge = 1;
+  var e = typeof Symbol == "function" && Symbol.for, i = e ? Symbol.for("react.element") : 60103, t = e ? Symbol.for("react.portal") : 60106, r = e ? Symbol.for("react.fragment") : 60107, n = e ? Symbol.for("react.strict_mode") : 60108, o = e ? Symbol.for("react.profiler") : 60114, a = e ? Symbol.for("react.provider") : 60109, s = e ? Symbol.for("react.context") : 60110, f = e ? Symbol.for("react.async_mode") : 60111, u = e ? Symbol.for("react.concurrent_mode") : 60111, p = e ? Symbol.for("react.forward_ref") : 60112, g = e ? Symbol.for("react.suspense") : 60113, b = e ? Symbol.for("react.suspense_list") : 60120, S = e ? Symbol.for("react.memo") : 60115, z = e ? Symbol.for("react.lazy") : 60116, w = e ? Symbol.for("react.block") : 60121, E = e ? Symbol.for("react.fundamental") : 60117, D = e ? Symbol.for("react.responder") : 60118, y = e ? Symbol.for("react.scope") : 60119;
+  function h(l) {
+    if (typeof l == "object" && l !== null) {
+      var R = l.$$typeof;
+      switch (R) {
+        case i:
+          switch (l = l.type, l) {
+            case f:
+            case u:
+            case r:
+            case o:
+            case n:
+            case g:
+              return l;
+            default:
+              switch (l = l && l.$$typeof, l) {
+                case s:
+                case p:
+                case z:
+                case S:
+                case a:
+                  return l;
+                default:
+                  return R;
+              }
+          }
+        case t:
+          return R;
+      }
+    }
+  }
+  function d(l) {
+    return h(l) === u;
+  }
+  return N.AsyncMode = f, N.ConcurrentMode = u, N.ContextConsumer = s, N.ContextProvider = a, N.Element = i, N.ForwardRef = p, N.Fragment = r, N.Lazy = z, N.Memo = S, N.Portal = t, N.Profiler = o, N.StrictMode = n, N.Suspense = g, N.isAsyncMode = function(l) {
+    return d(l) || h(l) === f;
+  }, N.isConcurrentMode = d, N.isContextConsumer = function(l) {
+    return h(l) === s;
+  }, N.isContextProvider = function(l) {
+    return h(l) === a;
+  }, N.isElement = function(l) {
+    return typeof l == "object" && l !== null && l.$$typeof === i;
+  }, N.isForwardRef = function(l) {
+    return h(l) === p;
+  }, N.isFragment = function(l) {
+    return h(l) === r;
+  }, N.isLazy = function(l) {
+    return h(l) === z;
+  }, N.isMemo = function(l) {
+    return h(l) === S;
+  }, N.isPortal = function(l) {
+    return h(l) === t;
+  }, N.isProfiler = function(l) {
+    return h(l) === o;
+  }, N.isStrictMode = function(l) {
+    return h(l) === n;
+  }, N.isSuspense = function(l) {
+    return h(l) === g;
+  }, N.isValidElementType = function(l) {
+    return typeof l == "string" || typeof l == "function" || l === r || l === u || l === o || l === n || l === g || l === b || typeof l == "object" && l !== null && (l.$$typeof === z || l.$$typeof === S || l.$$typeof === a || l.$$typeof === s || l.$$typeof === p || l.$$typeof === E || l.$$typeof === D || l.$$typeof === y || l.$$typeof === w);
+  }, N.typeOf = h, N;
+}
+var H = {};
+/** @license React v16.13.1
+ * react-is.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 Ve;
+function Mt() {
+  return Ve || (Ve = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = typeof Symbol == "function" && Symbol.for, i = e ? Symbol.for("react.element") : 60103, t = e ? Symbol.for("react.portal") : 60106, r = e ? Symbol.for("react.fragment") : 60107, n = e ? Symbol.for("react.strict_mode") : 60108, o = e ? Symbol.for("react.profiler") : 60114, a = e ? Symbol.for("react.provider") : 60109, s = e ? Symbol.for("react.context") : 60110, f = e ? Symbol.for("react.async_mode") : 60111, u = e ? Symbol.for("react.concurrent_mode") : 60111, p = e ? Symbol.for("react.forward_ref") : 60112, g = e ? Symbol.for("react.suspense") : 60113, b = e ? Symbol.for("react.suspense_list") : 60120, S = e ? Symbol.for("react.memo") : 60115, z = e ? Symbol.for("react.lazy") : 60116, w = e ? Symbol.for("react.block") : 60121, E = e ? Symbol.for("react.fundamental") : 60117, D = e ? Symbol.for("react.responder") : 60118, y = e ? Symbol.for("react.scope") : 60119;
+    function h(v) {
+      return typeof v == "string" || typeof v == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      v === r || v === u || v === o || v === n || v === g || v === b || typeof v == "object" && v !== null && (v.$$typeof === z || v.$$typeof === S || v.$$typeof === a || v.$$typeof === s || v.$$typeof === p || v.$$typeof === E || v.$$typeof === D || v.$$typeof === y || v.$$typeof === w);
+    }
+    function d(v) {
+      if (typeof v == "object" && v !== null) {
+        var se = v.$$typeof;
+        switch (se) {
+          case i:
+            var me = v.type;
+            switch (me) {
+              case f:
+              case u:
+              case r:
+              case o:
+              case n:
+              case g:
+                return me;
+              default:
+                var Ue = me && me.$$typeof;
+                switch (Ue) {
+                  case s:
+                  case p:
+                  case z:
+                  case S:
+                  case a:
+                    return Ue;
+                  default:
+                    return se;
+                }
+            }
+          case t:
+            return se;
+        }
+      }
+    }
+    var l = f, R = u, x = s, k = a, B = i, Y = p, X = r, j = z, q = S, V = t, ie = o, I = n, Z = g, ne = !1;
+    function K(v) {
+      return ne || (ne = !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.")), c(v) || d(v) === f;
+    }
+    function c(v) {
+      return d(v) === u;
+    }
+    function m(v) {
+      return d(v) === s;
+    }
+    function O(v) {
+      return d(v) === a;
+    }
+    function T(v) {
+      return typeof v == "object" && v !== null && v.$$typeof === i;
+    }
+    function P(v) {
+      return d(v) === p;
+    }
+    function M(v) {
+      return d(v) === r;
+    }
+    function _(v) {
+      return d(v) === z;
+    }
+    function C(v) {
+      return d(v) === S;
+    }
+    function W(v) {
+      return d(v) === t;
+    }
+    function L(v) {
+      return d(v) === o;
+    }
+    function A(v) {
+      return d(v) === n;
+    }
+    function Q(v) {
+      return d(v) === g;
+    }
+    H.AsyncMode = l, H.ConcurrentMode = R, H.ContextConsumer = x, H.ContextProvider = k, H.Element = B, H.ForwardRef = Y, H.Fragment = X, H.Lazy = j, H.Memo = q, H.Portal = V, H.Profiler = ie, H.StrictMode = I, H.Suspense = Z, H.isAsyncMode = K, H.isConcurrentMode = c, H.isContextConsumer = m, H.isContextProvider = O, H.isElement = T, H.isForwardRef = P, H.isFragment = M, H.isLazy = _, H.isMemo = C, H.isPortal = W, H.isProfiler = L, H.isStrictMode = A, H.isSuspense = Q, H.isValidElementType = h, H.typeOf = d;
+  }()), H;
+}
+var Ke;
+function pt() {
+  return Ke || (Ke = 1, process.env.NODE_ENV === "production" ? be.exports = Ot() : be.exports = Mt()), be.exports;
+}
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var Te, Je;
+function Wt() {
+  if (Je) return Te;
+  Je = 1;
+  var e = Object.getOwnPropertySymbols, i = Object.prototype.hasOwnProperty, t = Object.prototype.propertyIsEnumerable;
+  function r(o) {
+    if (o == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(o);
+  }
+  function n() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var o = new String("abc");
+      if (o[5] = "de", Object.getOwnPropertyNames(o)[0] === "5")
+        return !1;
+      for (var a = {}, s = 0; s < 10; s++)
+        a["_" + String.fromCharCode(s)] = s;
+      var f = Object.getOwnPropertyNames(a).map(function(p) {
+        return a[p];
+      });
+      if (f.join("") !== "0123456789")
+        return !1;
+      var u = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(p) {
+        u[p] = p;
+      }), Object.keys(Object.assign({}, u)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return Te = n() ? Object.assign : function(o, a) {
+    for (var s, f = r(o), u, p = 1; p < arguments.length; p++) {
+      s = Object(arguments[p]);
+      for (var g in s)
+        i.call(s, g) && (f[g] = s[g]);
+      if (e) {
+        u = e(s);
+        for (var b = 0; b < u.length; b++)
+          t.call(s, u[b]) && (f[u[b]] = s[u[b]]);
+      }
+    }
+    return f;
+  }, Te;
+}
+var Ce, Ze;
+function Ye() {
+  if (Ze) return Ce;
+  Ze = 1;
+  var e = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return Ce = e, Ce;
+}
+var Oe, Qe;
+function dt() {
+  return Qe || (Qe = 1, Oe = Function.call.bind(Object.prototype.hasOwnProperty)), Oe;
+}
+var Me, et;
+function At() {
+  if (et) return Me;
+  et = 1;
+  var e = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var i = Ye(), t = {}, r = dt();
+    e = function(o) {
+      var a = "Warning: " + o;
+      typeof console < "u" && console.error(a);
+      try {
+        throw new Error(a);
+      } catch {
+      }
+    };
+  }
+  function n(o, a, s, f, u) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var p in o)
+        if (r(o, p)) {
+          var g;
+          try {
+            if (typeof o[p] != "function") {
+              var b = Error(
+                (f || "React class") + ": " + s + " type `" + p + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof o[p] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw b.name = "Invariant Violation", b;
+            }
+            g = o[p](a, p, f, s, null, i);
+          } catch (z) {
+            g = z;
+          }
+          if (g && !(g instanceof Error) && e(
+            (f || "React class") + ": type specification of " + s + " `" + p + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof g + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), g instanceof Error && !(g.message in t)) {
+            t[g.message] = !0;
+            var S = u ? u() : "";
+            e(
+              "Failed " + s + " type: " + g.message + (S ?? "")
+            );
+          }
+        }
+    }
+  }
+  return n.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (t = {});
+  }, Me = n, Me;
+}
+var We, tt;
+function Nt() {
+  if (tt) return We;
+  tt = 1;
+  var e = pt(), i = Wt(), t = Ye(), r = dt(), n = At(), o = function() {
+  };
+  process.env.NODE_ENV !== "production" && (o = function(s) {
+    var f = "Warning: " + s;
+    typeof console < "u" && console.error(f);
+    try {
+      throw new Error(f);
+    } catch {
+    }
+  });
+  function a() {
+    return null;
+  }
+  return We = function(s, f) {
+    var u = typeof Symbol == "function" && Symbol.iterator, p = "@@iterator";
+    function g(c) {
+      var m = c && (u && c[u] || c[p]);
+      if (typeof m == "function")
+        return m;
+    }
+    var b = "<<anonymous>>", S = {
+      array: D("array"),
+      bigint: D("bigint"),
+      bool: D("boolean"),
+      func: D("function"),
+      number: D("number"),
+      object: D("object"),
+      string: D("string"),
+      symbol: D("symbol"),
+      any: y(),
+      arrayOf: h,
+      element: d(),
+      elementType: l(),
+      instanceOf: R,
+      node: Y(),
+      objectOf: k,
+      oneOf: x,
+      oneOfType: B,
+      shape: j,
+      exact: q
+    };
+    function z(c, m) {
+      return c === m ? c !== 0 || 1 / c === 1 / m : c !== c && m !== m;
+    }
+    function w(c, m) {
+      this.message = c, this.data = m && typeof m == "object" ? m : {}, this.stack = "";
+    }
+    w.prototype = Error.prototype;
+    function E(c) {
+      if (process.env.NODE_ENV !== "production")
+        var m = {}, O = 0;
+      function T(M, _, C, W, L, A, Q) {
+        if (W = W || b, A = A || C, Q !== t) {
+          if (f) {
+            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;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var se = W + ":" + C;
+            !m[se] && // Avoid spamming the console because they are often not actionable except for lib authors
+            O < 3 && (o(
+              "You are manually calling a React.PropTypes validation function for the `" + A + "` prop on `" + W + "`. 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."
+            ), m[se] = !0, O++);
+          }
+        }
+        return _[C] == null ? M ? _[C] === null ? new w("The " + L + " `" + A + "` is marked as required " + ("in `" + W + "`, but its value is `null`.")) : new w("The " + L + " `" + A + "` is marked as required in " + ("`" + W + "`, but its value is `undefined`.")) : null : c(_, C, W, L, A);
+      }
+      var P = T.bind(null, !1);
+      return P.isRequired = T.bind(null, !0), P;
+    }
+    function D(c) {
+      function m(O, T, P, M, _, C) {
+        var W = O[T], L = I(W);
+        if (L !== c) {
+          var A = Z(W);
+          return new w(
+            "Invalid " + M + " `" + _ + "` of type " + ("`" + A + "` supplied to `" + P + "`, expected ") + ("`" + c + "`."),
+            { expectedType: c }
+          );
+        }
+        return null;
+      }
+      return E(m);
+    }
+    function y() {
+      return E(a);
+    }
+    function h(c) {
+      function m(O, T, P, M, _) {
+        if (typeof c != "function")
+          return new w("Property `" + _ + "` of component `" + P + "` has invalid PropType notation inside arrayOf.");
+        var C = O[T];
+        if (!Array.isArray(C)) {
+          var W = I(C);
+          return new w("Invalid " + M + " `" + _ + "` of type " + ("`" + W + "` supplied to `" + P + "`, expected an array."));
+        }
+        for (var L = 0; L < C.length; L++) {
+          var A = c(C, L, P, M, _ + "[" + L + "]", t);
+          if (A instanceof Error)
+            return A;
+        }
+        return null;
+      }
+      return E(m);
+    }
+    function d() {
+      function c(m, O, T, P, M) {
+        var _ = m[O];
+        if (!s(_)) {
+          var C = I(_);
+          return new w("Invalid " + P + " `" + M + "` of type " + ("`" + C + "` supplied to `" + T + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return E(c);
+    }
+    function l() {
+      function c(m, O, T, P, M) {
+        var _ = m[O];
+        if (!e.isValidElementType(_)) {
+          var C = I(_);
+          return new w("Invalid " + P + " `" + M + "` of type " + ("`" + C + "` supplied to `" + T + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return E(c);
+    }
+    function R(c) {
+      function m(O, T, P, M, _) {
+        if (!(O[T] instanceof c)) {
+          var C = c.name || b, W = K(O[T]);
+          return new w("Invalid " + M + " `" + _ + "` of type " + ("`" + W + "` supplied to `" + P + "`, expected ") + ("instance of `" + C + "`."));
+        }
+        return null;
+      }
+      return E(m);
+    }
+    function x(c) {
+      if (!Array.isArray(c))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? o(
+          "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])."
+        ) : o("Invalid argument supplied to oneOf, expected an array.")), a;
+      function m(O, T, P, M, _) {
+        for (var C = O[T], W = 0; W < c.length; W++)
+          if (z(C, c[W]))
+            return null;
+        var L = JSON.stringify(c, function(Q, v) {
+          var se = Z(v);
+          return se === "symbol" ? String(v) : v;
+        });
+        return new w("Invalid " + M + " `" + _ + "` of value `" + String(C) + "` " + ("supplied to `" + P + "`, expected one of " + L + "."));
+      }
+      return E(m);
+    }
+    function k(c) {
+      function m(O, T, P, M, _) {
+        if (typeof c != "function")
+          return new w("Property `" + _ + "` of component `" + P + "` has invalid PropType notation inside objectOf.");
+        var C = O[T], W = I(C);
+        if (W !== "object")
+          return new w("Invalid " + M + " `" + _ + "` of type " + ("`" + W + "` supplied to `" + P + "`, expected an object."));
+        for (var L in C)
+          if (r(C, L)) {
+            var A = c(C, L, P, M, _ + "." + L, t);
+            if (A instanceof Error)
+              return A;
+          }
+        return null;
+      }
+      return E(m);
+    }
+    function B(c) {
+      if (!Array.isArray(c))
+        return process.env.NODE_ENV !== "production" && o("Invalid argument supplied to oneOfType, expected an instance of array."), a;
+      for (var m = 0; m < c.length; m++) {
+        var O = c[m];
+        if (typeof O != "function")
+          return o(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + ne(O) + " at index " + m + "."
+          ), a;
+      }
+      function T(P, M, _, C, W) {
+        for (var L = [], A = 0; A < c.length; A++) {
+          var Q = c[A], v = Q(P, M, _, C, W, t);
+          if (v == null)
+            return null;
+          v.data && r(v.data, "expectedType") && L.push(v.data.expectedType);
+        }
+        var se = L.length > 0 ? ", expected one of type [" + L.join(", ") + "]" : "";
+        return new w("Invalid " + C + " `" + W + "` supplied to " + ("`" + _ + "`" + se + "."));
+      }
+      return E(T);
+    }
+    function Y() {
+      function c(m, O, T, P, M) {
+        return V(m[O]) ? null : new w("Invalid " + P + " `" + M + "` supplied to " + ("`" + T + "`, expected a ReactNode."));
+      }
+      return E(c);
+    }
+    function X(c, m, O, T, P) {
+      return new w(
+        (c || "React class") + ": " + m + " type `" + O + "." + T + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + P + "`."
+      );
+    }
+    function j(c) {
+      function m(O, T, P, M, _) {
+        var C = O[T], W = I(C);
+        if (W !== "object")
+          return new w("Invalid " + M + " `" + _ + "` of type `" + W + "` " + ("supplied to `" + P + "`, expected `object`."));
+        for (var L in c) {
+          var A = c[L];
+          if (typeof A != "function")
+            return X(P, M, _, L, Z(A));
+          var Q = A(C, L, P, M, _ + "." + L, t);
+          if (Q)
+            return Q;
+        }
+        return null;
+      }
+      return E(m);
+    }
+    function q(c) {
+      function m(O, T, P, M, _) {
+        var C = O[T], W = I(C);
+        if (W !== "object")
+          return new w("Invalid " + M + " `" + _ + "` of type `" + W + "` " + ("supplied to `" + P + "`, expected `object`."));
+        var L = i({}, O[T], c);
+        for (var A in L) {
+          var Q = c[A];
+          if (r(c, A) && typeof Q != "function")
+            return X(P, M, _, A, Z(Q));
+          if (!Q)
+            return new w(
+              "Invalid " + M + " `" + _ + "` key `" + A + "` supplied to `" + P + "`.\nBad object: " + JSON.stringify(O[T], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(c), null, "  ")
+            );
+          var v = Q(C, A, P, M, _ + "." + A, t);
+          if (v)
+            return v;
+        }
+        return null;
+      }
+      return E(m);
+    }
+    function V(c) {
+      switch (typeof c) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !c;
+        case "object":
+          if (Array.isArray(c))
+            return c.every(V);
+          if (c === null || s(c))
+            return !0;
+          var m = g(c);
+          if (m) {
+            var O = m.call(c), T;
+            if (m !== c.entries) {
+              for (; !(T = O.next()).done; )
+                if (!V(T.value))
+                  return !1;
+            } else
+              for (; !(T = O.next()).done; ) {
+                var P = T.value;
+                if (P && !V(P[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function ie(c, m) {
+      return c === "symbol" ? !0 : m ? m["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && m instanceof Symbol : !1;
+    }
+    function I(c) {
+      var m = typeof c;
+      return Array.isArray(c) ? "array" : c instanceof RegExp ? "object" : ie(m, c) ? "symbol" : m;
+    }
+    function Z(c) {
+      if (typeof c > "u" || c === null)
+        return "" + c;
+      var m = I(c);
+      if (m === "object") {
+        if (c instanceof Date)
+          return "date";
+        if (c instanceof RegExp)
+          return "regexp";
+      }
+      return m;
+    }
+    function ne(c) {
+      var m = Z(c);
+      switch (m) {
+        case "array":
+        case "object":
+          return "an " + m;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + m;
+        default:
+          return m;
+      }
+    }
+    function K(c) {
+      return !c.constructor || !c.constructor.name ? b : c.constructor.name;
+    }
+    return S.checkPropTypes = n, S.resetWarningCache = n.resetWarningCache, S.PropTypes = S, S;
+  }, We;
+}
+var Ae, rt;
+function Ht() {
+  if (rt) return Ae;
+  rt = 1;
+  var e = Ye();
+  function i() {
+  }
+  function t() {
+  }
+  return t.resetWarningCache = i, Ae = function() {
+    function r(a, s, f, u, p, g) {
+      if (g !== e) {
+        var b = 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 b.name = "Invariant Violation", b;
+      }
+    }
+    r.isRequired = r;
+    function n() {
+      return r;
+    }
+    var o = {
+      array: r,
+      bigint: r,
+      bool: r,
+      func: r,
+      number: r,
+      object: r,
+      string: r,
+      symbol: r,
+      any: r,
+      arrayOf: n,
+      element: r,
+      elementType: r,
+      instanceOf: n,
+      node: r,
+      objectOf: n,
+      oneOf: n,
+      oneOfType: n,
+      shape: n,
+      exact: n,
+      checkPropTypes: t,
+      resetWarningCache: i
+    };
+    return o.PropTypes = o, o;
+  }, Ae;
+}
+if (process.env.NODE_ENV !== "production") {
+  var Lt = pt(), kt = !0;
+  je.exports = Nt()(Lt.isElement, kt);
+} else
+  je.exports = Ht()();
+var gt = je.exports;
+function vt(e) {
+  var i, t, r = "";
+  if (typeof e == "string" || typeof e == "number") r += e;
+  else if (typeof e == "object") if (Array.isArray(e)) for (i = 0; i < e.length; i++) e[i] && (t = vt(e[i])) && (r && (r += " "), r += t);
+  else for (i in e) e[i] && (r && (r += " "), r += i);
+  return r;
+}
+function it() {
+  for (var e, i, t = 0, r = ""; t < arguments.length; ) (e = arguments[t++]) && (i = vt(e)) && (r && (r += " "), r += i);
+  return r;
+}
+const jt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  clsx: it,
+  default: it
+}, Symbol.toStringTag, { value: "Module" })), It = /* @__PURE__ */ _t(jt);
+var $ = {}, le = {};
+Object.defineProperty(le, "__esModule", {
+  value: !0
+});
+le.dontSetMe = Ut;
+le.findInArray = Yt;
+le.int = Ft;
+le.isFunction = $t;
+le.isNum = Bt;
+function Yt(e, i) {
+  for (let t = 0, r = e.length; t < r; t++)
+    if (i.apply(i, [e[t], t, e])) return e[t];
+}
+function $t(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Function]";
+}
+function Bt(e) {
+  return typeof e == "number" && !isNaN(e);
+}
+function Ft(e) {
+  return parseInt(e, 10);
+}
+function Ut(e, i, t) {
+  if (e[i])
+    return new Error("Invalid prop ".concat(i, " passed to ").concat(t, " - do not set this, set it on the child."));
+}
+var de = {};
+Object.defineProperty(de, "__esModule", {
+  value: !0
+});
+de.browserPrefixToKey = mt;
+de.browserPrefixToStyle = Xt;
+de.default = void 0;
+de.getPrefix = yt;
+const Ne = ["Moz", "Webkit", "O", "ms"];
+function yt() {
+  var e;
+  let i = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "transform";
+  if (typeof window > "u") return "";
+  const t = (e = window.document) === null || e === void 0 || (e = e.documentElement) === null || e === void 0 ? void 0 : e.style;
+  if (!t || i in t) return "";
+  for (let r = 0; r < Ne.length; r++)
+    if (mt(i, Ne[r]) in t) return Ne[r];
+  return "";
+}
+function mt(e, i) {
+  return i ? "".concat(i).concat(qt(e)) : e;
+}
+function Xt(e, i) {
+  return i ? "-".concat(i.toLowerCase(), "-").concat(e) : e;
+}
+function qt(e) {
+  let i = "", t = !0;
+  for (let r = 0; r < e.length; r++)
+    t ? (i += e[r].toUpperCase(), t = !1) : e[r] === "-" ? t = !0 : i += e[r];
+  return i;
+}
+de.default = yt();
+Object.defineProperty($, "__esModule", {
+  value: !0
+});
+$.addClassName = St;
+$.addEvent = Kt;
+$.addUserSelectStyles = ar;
+$.createCSSTransform = ir;
+$.createSVGTransform = nr;
+$.getTouch = or;
+$.getTouchIdentifier = sr;
+$.getTranslation = $e;
+$.innerHeight = er;
+$.innerWidth = tr;
+$.matchesSelector = wt;
+$.matchesSelectorAndParentsTo = Vt;
+$.offsetXYFromParent = rr;
+$.outerHeight = Zt;
+$.outerWidth = Qt;
+$.removeClassName = xt;
+$.removeEvent = Jt;
+$.removeUserSelectStyles = lr;
+var re = le, nt = Gt(de);
+function bt(e) {
+  if (typeof WeakMap != "function") return null;
+  var i = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
+  return (bt = function(r) {
+    return r ? t : i;
+  })(e);
+}
+function Gt(e, i) {
+  if (e && e.__esModule)
+    return e;
+  if (e === null || typeof e != "object" && typeof e != "function")
+    return { default: e };
+  var t = bt(i);
+  if (t && t.has(e))
+    return t.get(e);
+  var r = {}, n = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var o in e)
+    if (o !== "default" && Object.prototype.hasOwnProperty.call(e, o)) {
+      var a = n ? Object.getOwnPropertyDescriptor(e, o) : null;
+      a && (a.get || a.set) ? Object.defineProperty(r, o, a) : r[o] = e[o];
+    }
+  return r.default = e, t && t.set(e, r), r;
+}
+let we = "";
+function wt(e, i) {
+  return we || (we = (0, re.findInArray)(["matches", "webkitMatchesSelector", "mozMatchesSelector", "msMatchesSelector", "oMatchesSelector"], function(t) {
+    return (0, re.isFunction)(e[t]);
+  })), (0, re.isFunction)(e[we]) ? e[we](i) : !1;
+}
+function Vt(e, i, t) {
+  let r = e;
+  do {
+    if (wt(r, i)) return !0;
+    if (r === t) return !1;
+    r = r.parentNode;
+  } while (r);
+  return !1;
+}
+function Kt(e, i, t, r) {
+  if (!e) return;
+  const n = {
+    capture: !0,
+    ...r
+  };
+  e.addEventListener ? e.addEventListener(i, t, n) : e.attachEvent ? e.attachEvent("on" + i, t) : e["on" + i] = t;
+}
+function Jt(e, i, t, r) {
+  if (!e) return;
+  const n = {
+    capture: !0,
+    ...r
+  };
+  e.removeEventListener ? e.removeEventListener(i, t, n) : e.detachEvent ? e.detachEvent("on" + i, t) : e["on" + i] = null;
+}
+function Zt(e) {
+  let i = e.clientHeight;
+  const t = e.ownerDocument.defaultView.getComputedStyle(e);
+  return i += (0, re.int)(t.borderTopWidth), i += (0, re.int)(t.borderBottomWidth), i;
+}
+function Qt(e) {
+  let i = e.clientWidth;
+  const t = e.ownerDocument.defaultView.getComputedStyle(e);
+  return i += (0, re.int)(t.borderLeftWidth), i += (0, re.int)(t.borderRightWidth), i;
+}
+function er(e) {
+  let i = e.clientHeight;
+  const t = e.ownerDocument.defaultView.getComputedStyle(e);
+  return i -= (0, re.int)(t.paddingTop), i -= (0, re.int)(t.paddingBottom), i;
+}
+function tr(e) {
+  let i = e.clientWidth;
+  const t = e.ownerDocument.defaultView.getComputedStyle(e);
+  return i -= (0, re.int)(t.paddingLeft), i -= (0, re.int)(t.paddingRight), i;
+}
+function rr(e, i, t) {
+  const n = i === i.ownerDocument.body ? {
+    left: 0,
+    top: 0
+  } : i.getBoundingClientRect(), o = (e.clientX + i.scrollLeft - n.left) / t, a = (e.clientY + i.scrollTop - n.top) / t;
+  return {
+    x: o,
+    y: a
+  };
+}
+function ir(e, i) {
+  const t = $e(e, i, "px");
+  return {
+    [(0, nt.browserPrefixToKey)("transform", nt.default)]: t
+  };
+}
+function nr(e, i) {
+  return $e(e, i, "");
+}
+function $e(e, i, t) {
+  let {
+    x: r,
+    y: n
+  } = e, o = "translate(".concat(r).concat(t, ",").concat(n).concat(t, ")");
+  if (i) {
+    const a = "".concat(typeof i.x == "string" ? i.x : i.x + t), s = "".concat(typeof i.y == "string" ? i.y : i.y + t);
+    o = "translate(".concat(a, ", ").concat(s, ")") + o;
+  }
+  return o;
+}
+function or(e, i) {
+  return e.targetTouches && (0, re.findInArray)(e.targetTouches, (t) => i === t.identifier) || e.changedTouches && (0, re.findInArray)(e.changedTouches, (t) => i === t.identifier);
+}
+function sr(e) {
+  if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;
+  if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;
+}
+function ar(e) {
+  if (!e) return;
+  let i = e.getElementById("react-draggable-style-el");
+  i || (i = e.createElement("style"), i.type = "text/css", i.id = "react-draggable-style-el", i.innerHTML = `.react-draggable-transparent-selection *::-moz-selection {all: inherit;}
+`, i.innerHTML += `.react-draggable-transparent-selection *::selection {all: inherit;}
+`, e.getElementsByTagName("head")[0].appendChild(i)), e.body && St(e.body, "react-draggable-transparent-selection");
+}
+function lr(e) {
+  if (e)
+    try {
+      if (e.body && xt(e.body, "react-draggable-transparent-selection"), e.selection)
+        e.selection.empty();
+      else {
+        const i = (e.defaultView || window).getSelection();
+        i && i.type !== "Caret" && i.removeAllRanges();
+      }
+    } catch {
+    }
+}
+function St(e, i) {
+  e.classList ? e.classList.add(i) : e.className.match(new RegExp("(?:^|\\s)".concat(i, "(?!\\S)"))) || (e.className += " ".concat(i));
+}
+function xt(e, i) {
+  e.classList ? e.classList.remove(i) : e.className = e.className.replace(new RegExp("(?:^|\\s)".concat(i, "(?!\\S)"), "g"), "");
+}
+var ue = {};
+Object.defineProperty(ue, "__esModule", {
+  value: !0
+});
+ue.canDragX = cr;
+ue.canDragY = hr;
+ue.createCoreData = dr;
+ue.createDraggableData = gr;
+ue.getBoundPosition = ur;
+ue.getControlPosition = pr;
+ue.snapToGrid = fr;
+var te = le, ve = $;
+function ur(e, i, t) {
+  if (!e.props.bounds) return [i, t];
+  let {
+    bounds: r
+  } = e.props;
+  r = typeof r == "string" ? r : vr(r);
+  const n = Be(e);
+  if (typeof r == "string") {
+    const {
+      ownerDocument: o
+    } = n, a = o.defaultView;
+    let s;
+    if (r === "parent" ? s = n.parentNode : s = o.querySelector(r), !(s instanceof a.HTMLElement))
+      throw new Error('Bounds selector "' + r + '" could not find an element.');
+    const f = s, u = a.getComputedStyle(n), p = a.getComputedStyle(f);
+    r = {
+      left: -n.offsetLeft + (0, te.int)(p.paddingLeft) + (0, te.int)(u.marginLeft),
+      top: -n.offsetTop + (0, te.int)(p.paddingTop) + (0, te.int)(u.marginTop),
+      right: (0, ve.innerWidth)(f) - (0, ve.outerWidth)(n) - n.offsetLeft + (0, te.int)(p.paddingRight) - (0, te.int)(u.marginRight),
+      bottom: (0, ve.innerHeight)(f) - (0, ve.outerHeight)(n) - n.offsetTop + (0, te.int)(p.paddingBottom) - (0, te.int)(u.marginBottom)
+    };
+  }
+  return (0, te.isNum)(r.right) && (i = Math.min(i, r.right)), (0, te.isNum)(r.bottom) && (t = Math.min(t, r.bottom)), (0, te.isNum)(r.left) && (i = Math.max(i, r.left)), (0, te.isNum)(r.top) && (t = Math.max(t, r.top)), [i, t];
+}
+function fr(e, i, t) {
+  const r = Math.round(i / e[0]) * e[0], n = Math.round(t / e[1]) * e[1];
+  return [r, n];
+}
+function cr(e) {
+  return e.props.axis === "both" || e.props.axis === "x";
+}
+function hr(e) {
+  return e.props.axis === "both" || e.props.axis === "y";
+}
+function pr(e, i, t) {
+  const r = typeof i == "number" ? (0, ve.getTouch)(e, i) : null;
+  if (typeof i == "number" && !r) return null;
+  const n = Be(t), o = t.props.offsetParent || n.offsetParent || n.ownerDocument.body;
+  return (0, ve.offsetXYFromParent)(r || e, o, t.props.scale);
+}
+function dr(e, i, t) {
+  const r = !(0, te.isNum)(e.lastX), n = Be(e);
+  return r ? {
+    node: n,
+    deltaX: 0,
+    deltaY: 0,
+    lastX: i,
+    lastY: t,
+    x: i,
+    y: t
+  } : {
+    node: n,
+    deltaX: i - e.lastX,
+    deltaY: t - e.lastY,
+    lastX: e.lastX,
+    lastY: e.lastY,
+    x: i,
+    y: t
+  };
+}
+function gr(e, i) {
+  const t = e.props.scale;
+  return {
+    node: i.node,
+    x: e.state.x + i.deltaX / t,
+    y: e.state.y + i.deltaY / t,
+    deltaX: i.deltaX / t,
+    deltaY: i.deltaY / t,
+    lastX: e.state.x,
+    lastY: e.state.y
+  };
+}
+function vr(e) {
+  return {
+    left: e.left,
+    top: e.top,
+    right: e.right,
+    bottom: e.bottom
+  };
+}
+function Be(e) {
+  const i = e.findDOMNode();
+  if (!i)
+    throw new Error("<DraggableCore>: Unmounted during event!");
+  return i;
+}
+var Re = {}, _e = {};
+Object.defineProperty(_e, "__esModule", {
+  value: !0
+});
+_e.default = yr;
+function yr() {
+}
+Object.defineProperty(Re, "__esModule", {
+  value: !0
+});
+Re.default = void 0;
+var He = br(ft), ee = Fe(gt), mr = Fe(ct), G = $, fe = ue, Le = le, ye = Fe(_e);
+function Fe(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+function zt(e) {
+  if (typeof WeakMap != "function") return null;
+  var i = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
+  return (zt = function(r) {
+    return r ? t : i;
+  })(e);
+}
+function br(e, i) {
+  if (e && e.__esModule)
+    return e;
+  if (e === null || typeof e != "object" && typeof e != "function")
+    return { default: e };
+  var t = zt(i);
+  if (t && t.has(e))
+    return t.get(e);
+  var r = {}, n = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var o in e)
+    if (o !== "default" && Object.prototype.hasOwnProperty.call(e, o)) {
+      var a = n ? Object.getOwnPropertyDescriptor(e, o) : null;
+      a && (a.get || a.set) ? Object.defineProperty(r, o, a) : r[o] = e[o];
+    }
+  return r.default = e, t && t.set(e, r), r;
+}
+function J(e, i, t) {
+  return i = wr(i), i in e ? Object.defineProperty(e, i, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[i] = t, e;
+}
+function wr(e) {
+  var i = Sr(e, "string");
+  return typeof i == "symbol" ? i : String(i);
+}
+function Sr(e, i) {
+  if (typeof e != "object" || e === null) return e;
+  var t = e[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var r = t.call(e, i || "default");
+    if (typeof r != "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (i === "string" ? String : Number)(e);
+}
+const oe = {
+  touch: {
+    start: "touchstart",
+    move: "touchmove",
+    stop: "touchend"
+  },
+  mouse: {
+    start: "mousedown",
+    move: "mousemove",
+    stop: "mouseup"
+  }
+};
+let ce = oe.mouse, De = class extends He.Component {
+  constructor() {
+    super(...arguments), J(this, "dragging", !1), J(this, "lastX", NaN), J(this, "lastY", NaN), J(this, "touchIdentifier", null), J(this, "mounted", !1), J(this, "handleDragStart", (i) => {
+      if (this.props.onMouseDown(i), !this.props.allowAnyClick && typeof i.button == "number" && i.button !== 0) return !1;
+      const t = this.findDOMNode();
+      if (!t || !t.ownerDocument || !t.ownerDocument.body)
+        throw new Error("<DraggableCore> not mounted on DragStart!");
+      const {
+        ownerDocument: r
+      } = t;
+      if (this.props.disabled || !(i.target instanceof r.defaultView.Node) || this.props.handle && !(0, G.matchesSelectorAndParentsTo)(i.target, this.props.handle, t) || this.props.cancel && (0, G.matchesSelectorAndParentsTo)(i.target, this.props.cancel, t))
+        return;
+      i.type === "touchstart" && i.preventDefault();
+      const n = (0, G.getTouchIdentifier)(i);
+      this.touchIdentifier = n;
+      const o = (0, fe.getControlPosition)(i, n, this);
+      if (o == null) return;
+      const {
+        x: a,
+        y: s
+      } = o, f = (0, fe.createCoreData)(this, a, s);
+      (0, ye.default)("DraggableCore: handleDragStart: %j", f), (0, ye.default)("calling", this.props.onStart), !(this.props.onStart(i, f) === !1 || this.mounted === !1) && (this.props.enableUserSelectHack && (0, G.addUserSelectStyles)(r), this.dragging = !0, this.lastX = a, this.lastY = s, (0, G.addEvent)(r, ce.move, this.handleDrag), (0, G.addEvent)(r, ce.stop, this.handleDragStop));
+    }), J(this, "handleDrag", (i) => {
+      const t = (0, fe.getControlPosition)(i, this.touchIdentifier, this);
+      if (t == null) return;
+      let {
+        x: r,
+        y: n
+      } = t;
+      if (Array.isArray(this.props.grid)) {
+        let s = r - this.lastX, f = n - this.lastY;
+        if ([s, f] = (0, fe.snapToGrid)(this.props.grid, s, f), !s && !f) return;
+        r = this.lastX + s, n = this.lastY + f;
+      }
+      const o = (0, fe.createCoreData)(this, r, n);
+      if ((0, ye.default)("DraggableCore: handleDrag: %j", o), this.props.onDrag(i, o) === !1 || this.mounted === !1) {
+        try {
+          this.handleDragStop(new MouseEvent("mouseup"));
+        } catch {
+          const f = document.createEvent("MouseEvents");
+          f.initMouseEvent("mouseup", !0, !0, window, 0, 0, 0, 0, 0, !1, !1, !1, !1, 0, null), this.handleDragStop(f);
+        }
+        return;
+      }
+      this.lastX = r, this.lastY = n;
+    }), J(this, "handleDragStop", (i) => {
+      if (!this.dragging) return;
+      const t = (0, fe.getControlPosition)(i, this.touchIdentifier, this);
+      if (t == null) return;
+      let {
+        x: r,
+        y: n
+      } = t;
+      if (Array.isArray(this.props.grid)) {
+        let f = r - this.lastX || 0, u = n - this.lastY || 0;
+        [f, u] = (0, fe.snapToGrid)(this.props.grid, f, u), r = this.lastX + f, n = this.lastY + u;
+      }
+      const o = (0, fe.createCoreData)(this, r, n);
+      if (this.props.onStop(i, o) === !1 || this.mounted === !1) return !1;
+      const s = this.findDOMNode();
+      s && this.props.enableUserSelectHack && (0, G.removeUserSelectStyles)(s.ownerDocument), (0, ye.default)("DraggableCore: handleDragStop: %j", o), this.dragging = !1, this.lastX = NaN, this.lastY = NaN, s && ((0, ye.default)("DraggableCore: Removing handlers"), (0, G.removeEvent)(s.ownerDocument, ce.move, this.handleDrag), (0, G.removeEvent)(s.ownerDocument, ce.stop, this.handleDragStop));
+    }), J(this, "onMouseDown", (i) => (ce = oe.mouse, this.handleDragStart(i))), J(this, "onMouseUp", (i) => (ce = oe.mouse, this.handleDragStop(i))), J(this, "onTouchStart", (i) => (ce = oe.touch, this.handleDragStart(i))), J(this, "onTouchEnd", (i) => (ce = oe.touch, this.handleDragStop(i)));
+  }
+  componentDidMount() {
+    this.mounted = !0;
+    const i = this.findDOMNode();
+    i && (0, G.addEvent)(i, oe.touch.start, this.onTouchStart, {
+      passive: !1
+    });
+  }
+  componentWillUnmount() {
+    this.mounted = !1;
+    const i = this.findDOMNode();
+    if (i) {
+      const {
+        ownerDocument: t
+      } = i;
+      (0, G.removeEvent)(t, oe.mouse.move, this.handleDrag), (0, G.removeEvent)(t, oe.touch.move, this.handleDrag), (0, G.removeEvent)(t, oe.mouse.stop, this.handleDragStop), (0, G.removeEvent)(t, oe.touch.stop, this.handleDragStop), (0, G.removeEvent)(i, oe.touch.start, this.onTouchStart, {
+        passive: !1
+      }), this.props.enableUserSelectHack && (0, G.removeUserSelectStyles)(t);
+    }
+  }
+  // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find
+  // the underlying DOM node ourselves. See the README for more information.
+  findDOMNode() {
+    var i, t;
+    return (i = this.props) !== null && i !== void 0 && i.nodeRef ? (t = this.props) === null || t === void 0 || (t = t.nodeRef) === null || t === void 0 ? void 0 : t.current : mr.default.findDOMNode(this);
+  }
+  render() {
+    return /* @__PURE__ */ He.cloneElement(He.Children.only(this.props.children), {
+      // Note: mouseMove handler is attached to document so it will still function
+      // when the user drags quickly and leaves the bounds of the element.
+      onMouseDown: this.onMouseDown,
+      onMouseUp: this.onMouseUp,
+      // onTouchStart is added on `componentDidMount` so they can be added with
+      // {passive: false}, which allows it to cancel. See
+      // https://developers.google.com/web/updates/2017/01/scrolling-intervention
+      onTouchEnd: this.onTouchEnd
+    });
+  }
+};
+Re.default = De;
+J(De, "displayName", "DraggableCore");
+J(De, "propTypes", {
+  /**
+   * `allowAnyClick` allows dragging using any mouse button.
+   * By default, we only accept the left button.
+   *
+   * Defaults to `false`.
+   */
+  allowAnyClick: ee.default.bool,
+  children: ee.default.node.isRequired,
+  /**
+   * `disabled`, if true, stops the <Draggable> from dragging. All handlers,
+   * with the exception of `onMouseDown`, will not fire.
+   */
+  disabled: ee.default.bool,
+  /**
+   * By default, we add 'user-select:none' attributes to the document body
+   * to prevent ugly text selection during drag. If this is causing problems
+   * for your app, set this to `false`.
+   */
+  enableUserSelectHack: ee.default.bool,
+  /**
+   * `offsetParent`, if set, uses the passed DOM node to compute drag offsets
+   * instead of using the parent node.
+   */
+  offsetParent: function(e, i) {
+    if (e[i] && e[i].nodeType !== 1)
+      throw new Error("Draggable's offsetParent must be a DOM Node.");
+  },
+  /**
+   * `grid` specifies the x and y that dragging should snap to.
+   */
+  grid: ee.default.arrayOf(ee.default.number),
+  /**
+   * `handle` specifies a selector to be used as the handle that initiates drag.
+   *
+   * Example:
+   *
+   * ```jsx
+   *   let App = React.createClass({
+   *       render: function () {
+   *         return (
+   *            <Draggable handle=".handle">
+   *              <div>
+   *                  <div className="handle">Click me to drag</div>
+   *                  <div>This is some other content</div>
+   *              </div>
+   *           </Draggable>
+   *         );
+   *       }
+   *   });
+   * ```
+   */
+  handle: ee.default.string,
+  /**
+   * `cancel` specifies a selector to be used to prevent drag initialization.
+   *
+   * Example:
+   *
+   * ```jsx
+   *   let App = React.createClass({
+   *       render: function () {
+   *           return(
+   *               <Draggable cancel=".cancel">
+   *                   <div>
+   *                     <div className="cancel">You can't drag from here</div>
+   *                     <div>Dragging here works fine</div>
+   *                   </div>
+   *               </Draggable>
+   *           );
+   *       }
+   *   });
+   * ```
+   */
+  cancel: ee.default.string,
+  /* If running in React Strict mode, ReactDOM.findDOMNode() is deprecated.
+   * Unfortunately, in order for <Draggable> to work properly, we need raw access
+   * to the underlying DOM node. If you want to avoid the warning, pass a `nodeRef`
+   * as in this example:
+   *
+   * function MyComponent() {
+   *   const nodeRef = React.useRef(null);
+   *   return (
+   *     <Draggable nodeRef={nodeRef}>
+   *       <div ref={nodeRef}>Example Target</div>
+   *     </Draggable>
+   *   );
+   * }
+   *
+   * This can be used for arbitrarily nested components, so long as the ref ends up
+   * pointing to the actual child DOM node and not a custom component.
+   */
+  nodeRef: ee.default.object,
+  /**
+   * Called when dragging starts.
+   * If this function returns the boolean false, dragging will be canceled.
+   */
+  onStart: ee.default.func,
+  /**
+   * Called while dragging.
+   * If this function returns the boolean false, dragging will be canceled.
+   */
+  onDrag: ee.default.func,
+  /**
+   * Called when dragging stops.
+   * If this function returns the boolean false, the drag will remain active.
+   */
+  onStop: ee.default.func,
+  /**
+   * A workaround option which can be passed if onMouseDown needs to be accessed,
+   * since it'll always be blocked (as there is internal use of onMouseDown)
+   */
+  onMouseDown: ee.default.func,
+  /**
+   * `scale`, if set, applies scaling while dragging an element
+   */
+  scale: ee.default.number,
+  /**
+   * These properties should be defined on the child, not here.
+   */
+  className: Le.dontSetMe,
+  style: Le.dontSetMe,
+  transform: Le.dontSetMe
+});
+J(De, "defaultProps", {
+  allowAnyClick: !1,
+  // by default only accept left click
+  disabled: !1,
+  enableUserSelectHack: !0,
+  onStart: function() {
+  },
+  onDrag: function() {
+  },
+  onStop: function() {
+  },
+  onMouseDown: function() {
+  },
+  scale: 1
+});
+(function(e) {
+  Object.defineProperty(e, "__esModule", {
+    value: !0
+  }), Object.defineProperty(e, "DraggableCore", {
+    enumerable: !0,
+    get: function() {
+      return f.default;
+    }
+  }), e.default = void 0;
+  var i = b(ft), t = p(gt), r = p(ct), n = p(It), o = $, a = ue, s = le, f = p(Re), u = p(_e);
+  function p(y) {
+    return y && y.__esModule ? y : { default: y };
+  }
+  function g(y) {
+    if (typeof WeakMap != "function") return null;
+    var h = /* @__PURE__ */ new WeakMap(), d = /* @__PURE__ */ new WeakMap();
+    return (g = function(l) {
+      return l ? d : h;
+    })(y);
+  }
+  function b(y, h) {
+    if (y && y.__esModule)
+      return y;
+    if (y === null || typeof y != "object" && typeof y != "function")
+      return { default: y };
+    var d = g(h);
+    if (d && d.has(y))
+      return d.get(y);
+    var l = {}, R = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var x in y)
+      if (x !== "default" && Object.prototype.hasOwnProperty.call(y, x)) {
+        var k = R ? Object.getOwnPropertyDescriptor(y, x) : null;
+        k && (k.get || k.set) ? Object.defineProperty(l, x, k) : l[x] = y[x];
+      }
+    return l.default = y, d && d.set(y, l), l;
+  }
+  function S() {
+    return S = Object.assign ? Object.assign.bind() : function(y) {
+      for (var h = 1; h < arguments.length; h++) {
+        var d = arguments[h];
+        for (var l in d)
+          Object.prototype.hasOwnProperty.call(d, l) && (y[l] = d[l]);
+      }
+      return y;
+    }, S.apply(this, arguments);
+  }
+  function z(y, h, d) {
+    return h = w(h), h in y ? Object.defineProperty(y, h, { value: d, enumerable: !0, configurable: !0, writable: !0 }) : y[h] = d, y;
+  }
+  function w(y) {
+    var h = E(y, "string");
+    return typeof h == "symbol" ? h : String(h);
+  }
+  function E(y, h) {
+    if (typeof y != "object" || y === null) return y;
+    var d = y[Symbol.toPrimitive];
+    if (d !== void 0) {
+      var l = d.call(y, h || "default");
+      if (typeof l != "object") return l;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (h === "string" ? String : Number)(y);
+  }
+  class D extends i.Component {
+    // React 16.3+
+    // Arity (props, state)
+    static getDerivedStateFromProps(h, d) {
+      let {
+        position: l
+      } = h, {
+        prevPropsPosition: R
+      } = d;
+      return l && (!R || l.x !== R.x || l.y !== R.y) ? ((0, u.default)("Draggable: getDerivedStateFromProps %j", {
+        position: l,
+        prevPropsPosition: R
+      }), {
+        x: l.x,
+        y: l.y,
+        prevPropsPosition: {
+          ...l
+        }
+      }) : null;
+    }
+    constructor(h) {
+      super(h), z(this, "onDragStart", (d, l) => {
+        if ((0, u.default)("Draggable: onDragStart: %j", l), this.props.onStart(d, (0, a.createDraggableData)(this, l)) === !1) return !1;
+        this.setState({
+          dragging: !0,
+          dragged: !0
+        });
+      }), z(this, "onDrag", (d, l) => {
+        if (!this.state.dragging) return !1;
+        (0, u.default)("Draggable: onDrag: %j", l);
+        const R = (0, a.createDraggableData)(this, l), x = {
+          x: R.x,
+          y: R.y,
+          slackX: 0,
+          slackY: 0
+        };
+        if (this.props.bounds) {
+          const {
+            x: B,
+            y: Y
+          } = x;
+          x.x += this.state.slackX, x.y += this.state.slackY;
+          const [X, j] = (0, a.getBoundPosition)(this, x.x, x.y);
+          x.x = X, x.y = j, x.slackX = this.state.slackX + (B - x.x), x.slackY = this.state.slackY + (Y - x.y), R.x = x.x, R.y = x.y, R.deltaX = x.x - this.state.x, R.deltaY = x.y - this.state.y;
+        }
+        if (this.props.onDrag(d, R) === !1) return !1;
+        this.setState(x);
+      }), z(this, "onDragStop", (d, l) => {
+        if (!this.state.dragging || this.props.onStop(d, (0, a.createDraggableData)(this, l)) === !1) return !1;
+        (0, u.default)("Draggable: onDragStop: %j", l);
+        const x = {
+          dragging: !1,
+          slackX: 0,
+          slackY: 0
+        };
+        if (!!this.props.position) {
+          const {
+            x: B,
+            y: Y
+          } = this.props.position;
+          x.x = B, x.y = Y;
+        }
+        this.setState(x);
+      }), this.state = {
+        // Whether or not we are currently dragging.
+        dragging: !1,
+        // Whether or not we have been dragged before.
+        dragged: !1,
+        // Current transform x and y.
+        x: h.position ? h.position.x : h.defaultPosition.x,
+        y: h.position ? h.position.y : h.defaultPosition.y,
+        prevPropsPosition: {
+          ...h.position
+        },
+        // Used for compensating for out-of-bounds drags
+        slackX: 0,
+        slackY: 0,
+        // Can only determine if SVG after mounting
+        isElementSVG: !1
+      }, h.position && !(h.onDrag || h.onStop) && console.warn("A `position` was applied to this <Draggable>, without drag handlers. This will make this component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the `position` of this element.");
+    }
+    componentDidMount() {
+      typeof window.SVGElement < "u" && this.findDOMNode() instanceof window.SVGElement && this.setState({
+        isElementSVG: !0
+      });
+    }
+    componentWillUnmount() {
+      this.setState({
+        dragging: !1
+      });
+    }
+    // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find
+    // the underlying DOM node ourselves. See the README for more information.
+    findDOMNode() {
+      var h, d;
+      return (h = (d = this.props) === null || d === void 0 || (d = d.nodeRef) === null || d === void 0 ? void 0 : d.current) !== null && h !== void 0 ? h : r.default.findDOMNode(this);
+    }
+    render() {
+      const {
+        axis: h,
+        bounds: d,
+        children: l,
+        defaultPosition: R,
+        defaultClassName: x,
+        defaultClassNameDragging: k,
+        defaultClassNameDragged: B,
+        position: Y,
+        positionOffset: X,
+        scale: j,
+        ...q
+      } = this.props;
+      let V = {}, ie = null;
+      const Z = !!!Y || this.state.dragging, ne = Y || R, K = {
+        // Set left if horizontal drag is enabled
+        x: (0, a.canDragX)(this) && Z ? this.state.x : ne.x,
+        // Set top if vertical drag is enabled
+        y: (0, a.canDragY)(this) && Z ? this.state.y : ne.y
+      };
+      this.state.isElementSVG ? ie = (0, o.createSVGTransform)(K, X) : V = (0, o.createCSSTransform)(K, X);
+      const c = (0, n.default)(l.props.className || "", x, {
+        [k]: this.state.dragging,
+        [B]: this.state.dragged
+      });
+      return /* @__PURE__ */ i.createElement(f.default, S({}, q, {
+        onStart: this.onDragStart,
+        onDrag: this.onDrag,
+        onStop: this.onDragStop
+      }), /* @__PURE__ */ i.cloneElement(i.Children.only(l), {
+        className: c,
+        style: {
+          ...l.props.style,
+          ...V
+        },
+        transform: ie
+      }));
+    }
+  }
+  e.default = D, z(D, "displayName", "Draggable"), z(D, "propTypes", {
+    // Accepts all props <DraggableCore> accepts.
+    ...f.default.propTypes,
+    /**
+     * `axis` determines which axis the draggable can move.
+     *
+     *  Note that all callbacks will still return data as normal. This only
+     *  controls flushing to the DOM.
+     *
+     * 'both' allows movement horizontally and vertically.
+     * 'x' limits movement to horizontal axis.
+     * 'y' limits movement to vertical axis.
+     * 'none' limits all movement.
+     *
+     * Defaults to 'both'.
+     */
+    axis: t.default.oneOf(["both", "x", "y", "none"]),
+    /**
+     * `bounds` determines the range of movement available to the element.
+     * Available values are:
+     *
+     * 'parent' restricts movement within the Draggable's parent node.
+     *
+     * Alternatively, pass an object with the following properties, all of which are optional:
+     *
+     * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}
+     *
+     * All values are in px.
+     *
+     * Example:
+     *
+     * ```jsx
+     *   let App = React.createClass({
+     *       render: function () {
+     *         return (
+     *            <Draggable bounds={{right: 300, bottom: 300}}>
+     *              <div>Content</div>
+     *           </Draggable>
+     *         );
+     *       }
+     *   });
+     * ```
+     */
+    bounds: t.default.oneOfType([t.default.shape({
+      left: t.default.number,
+      right: t.default.number,
+      top: t.default.number,
+      bottom: t.default.number
+    }), t.default.string, t.default.oneOf([!1])]),
+    defaultClassName: t.default.string,
+    defaultClassNameDragging: t.default.string,
+    defaultClassNameDragged: t.default.string,
+    /**
+     * `defaultPosition` specifies the x and y that the dragged item should start at
+     *
+     * Example:
+     *
+     * ```jsx
+     *      let App = React.createClass({
+     *          render: function () {
+     *              return (
+     *                  <Draggable defaultPosition={{x: 25, y: 25}}>
+     *                      <div>I start with transformX: 25px and transformY: 25px;</div>
+     *                  </Draggable>
+     *              );
+     *          }
+     *      });
+     * ```
+     */
+    defaultPosition: t.default.shape({
+      x: t.default.number,
+      y: t.default.number
+    }),
+    positionOffset: t.default.shape({
+      x: t.default.oneOfType([t.default.number, t.default.string]),
+      y: t.default.oneOfType([t.default.number, t.default.string])
+    }),
+    /**
+     * `position`, if present, defines the current position of the element.
+     *
+     *  This is similar to how form elements in React work - if no `position` is supplied, the component
+     *  is uncontrolled.
+     *
+     * Example:
+     *
+     * ```jsx
+     *      let App = React.createClass({
+     *          render: function () {
+     *              return (
+     *                  <Draggable position={{x: 25, y: 25}}>
+     *                      <div>I start with transformX: 25px and transformY: 25px;</div>
+     *                  </Draggable>
+     *              );
+     *          }
+     *      });
+     * ```
+     */
+    position: t.default.shape({
+      x: t.default.number,
+      y: t.default.number
+    }),
+    /**
+     * These properties should be defined on the child, not here.
+     */
+    className: s.dontSetMe,
+    style: s.dontSetMe,
+    transform: s.dontSetMe
+  }), z(D, "defaultProps", {
+    ...f.default.defaultProps,
+    axis: "both",
+    bounds: !1,
+    defaultClassName: "react-draggable",
+    defaultClassNameDragging: "react-draggable-dragging",
+    defaultClassNameDragged: "react-draggable-dragged",
+    defaultPosition: {
+      x: 0,
+      y: 0
+    },
+    scale: 1
+  });
+})(ht);
+const {
+  default: Et,
+  DraggableCore: xr
+} = ht;
+Pe.exports = Et;
+Pe.exports.default = Et;
+Pe.exports.DraggableCore = xr;
+var zr = Pe.exports;
+const Er = /* @__PURE__ */ Dt(zr);
+var Pr = /* @__PURE__ */ function() {
+  var e = function(i, t) {
+    return e = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+      r.__proto__ = n;
+    } || function(r, n) {
+      for (var o in n) Object.prototype.hasOwnProperty.call(n, o) && (r[o] = n[o]);
+    }, e(i, t);
+  };
+  return function(i, t) {
+    e(i, t);
+    function r() {
+      this.constructor = i;
+    }
+    i.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+  };
+}(), F = function() {
+  return F = Object.assign || function(e) {
+    for (var i, t = 1, r = arguments.length; t < r; t++) {
+      i = arguments[t];
+      for (var n in i) Object.prototype.hasOwnProperty.call(i, n) && (e[n] = i[n]);
+    }
+    return e;
+  }, F.apply(this, arguments);
+}, ot = {
+  width: "100%",
+  height: "10px",
+  top: "0px",
+  left: "0px",
+  cursor: "row-resize"
+}, st = {
+  width: "10px",
+  height: "100%",
+  top: "0px",
+  left: "0px",
+  cursor: "col-resize"
+}, Se = {
+  width: "20px",
+  height: "20px",
+  position: "absolute"
+}, Rr = {
+  top: F(F({}, ot), { top: "-5px" }),
+  right: F(F({}, st), { left: void 0, right: "-5px" }),
+  bottom: F(F({}, ot), { top: void 0, bottom: "-5px" }),
+  left: F(F({}, st), { left: "-5px" }),
+  topRight: F(F({}, Se), { right: "-10px", top: "-10px", cursor: "ne-resize" }),
+  bottomRight: F(F({}, Se), { right: "-10px", bottom: "-10px", cursor: "se-resize" }),
+  bottomLeft: F(F({}, Se), { left: "-10px", bottom: "-10px", cursor: "sw-resize" }),
+  topLeft: F(F({}, Se), { left: "-10px", top: "-10px", cursor: "nw-resize" })
+}, _r = (
+  /** @class */
+  function(e) {
+    Pr(i, e);
+    function i() {
+      var t = e !== null && e.apply(this, arguments) || this;
+      return t.onMouseDown = function(r) {
+        t.props.onResizeStart(r, t.props.direction);
+      }, t.onTouchStart = function(r) {
+        t.props.onResizeStart(r, t.props.direction);
+      }, t;
+    }
+    return i.prototype.render = function() {
+      return pe.createElement("div", { className: this.props.className || "", style: F(F({ position: "absolute", userSelect: "none" }, Rr[this.props.direction]), this.props.replaceStyles || {}), onMouseDown: this.onMouseDown, onTouchStart: this.onTouchStart }, this.props.children);
+    }, i;
+  }(pe.PureComponent)
+), Dr = /* @__PURE__ */ function() {
+  var e = function(i, t) {
+    return e = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+      r.__proto__ = n;
+    } || function(r, n) {
+      for (var o in n) Object.prototype.hasOwnProperty.call(n, o) && (r[o] = n[o]);
+    }, e(i, t);
+  };
+  return function(i, t) {
+    e(i, t);
+    function r() {
+      this.constructor = i;
+    }
+    i.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+  };
+}(), ae = function() {
+  return ae = Object.assign || function(e) {
+    for (var i, t = 1, r = arguments.length; t < r; t++) {
+      i = arguments[t];
+      for (var n in i) Object.prototype.hasOwnProperty.call(i, n) && (e[n] = i[n]);
+    }
+    return e;
+  }, ae.apply(this, arguments);
+}, Tr = {
+  width: "auto",
+  height: "auto"
+}, xe = function(e, i, t) {
+  return Math.max(Math.min(e, t), i);
+}, at = function(e, i) {
+  return Math.round(e / i) * i;
+}, ge = function(e, i) {
+  return new RegExp(e, "i").test(i);
+}, ze = function(e) {
+  return !!(e.touches && e.touches.length);
+}, Cr = function(e) {
+  return !!((e.clientX || e.clientX === 0) && (e.clientY || e.clientY === 0));
+}, lt = function(e, i, t) {
+  t === void 0 && (t = 0);
+  var r = i.reduce(function(o, a, s) {
+    return Math.abs(a - e) < Math.abs(i[o] - e) ? s : o;
+  }, 0), n = Math.abs(i[r] - e);
+  return t === 0 || n < t ? i[r] : e;
+}, ke = function(e) {
+  return e = e.toString(), e === "auto" || e.endsWith("px") || e.endsWith("%") || e.endsWith("vh") || e.endsWith("vw") || e.endsWith("vmax") || e.endsWith("vmin") ? e : e + "px";
+}, Ee = function(e, i, t, r) {
+  if (e && typeof e == "string") {
+    if (e.endsWith("px"))
+      return Number(e.replace("px", ""));
+    if (e.endsWith("%")) {
+      var n = Number(e.replace("%", "")) / 100;
+      return i * n;
+    }
+    if (e.endsWith("vw")) {
+      var n = Number(e.replace("vw", "")) / 100;
+      return t * n;
+    }
+    if (e.endsWith("vh")) {
+      var n = Number(e.replace("vh", "")) / 100;
+      return r * n;
+    }
+  }
+  return e;
+}, Or = function(e, i, t, r, n, o, a) {
+  return r = Ee(r, e.width, i, t), n = Ee(n, e.height, i, t), o = Ee(o, e.width, i, t), a = Ee(a, e.height, i, t), {
+    maxWidth: typeof r > "u" ? void 0 : Number(r),
+    maxHeight: typeof n > "u" ? void 0 : Number(n),
+    minWidth: typeof o > "u" ? void 0 : Number(o),
+    minHeight: typeof a > "u" ? void 0 : Number(a)
+  };
+}, Mr = function(e) {
+  return Array.isArray(e) ? e : [e, e];
+}, Wr = [
+  "as",
+  "ref",
+  "style",
+  "className",
+  "grid",
+  "snap",
+  "bounds",
+  "boundsByDirection",
+  "size",
+  "defaultSize",
+  "minWidth",
+  "minHeight",
+  "maxWidth",
+  "maxHeight",
+  "lockAspectRatio",
+  "lockAspectRatioExtraWidth",
+  "lockAspectRatioExtraHeight",
+  "enable",
+  "handleStyles",
+  "handleClasses",
+  "handleWrapperStyle",
+  "handleWrapperClass",
+  "children",
+  "onResizeStart",
+  "onResize",
+  "onResizeStop",
+  "handleComponent",
+  "scale",
+  "resizeRatio",
+  "snapGap"
+], ut = "__resizable_base__", Ar = (
+  /** @class */
+  function(e) {
+    Dr(i, e);
+    function i(t) {
+      var r, n, o, a, s = e.call(this, t) || this;
+      return s.ratio = 1, s.resizable = null, s.parentLeft = 0, s.parentTop = 0, s.resizableLeft = 0, s.resizableRight = 0, s.resizableTop = 0, s.resizableBottom = 0, s.targetLeft = 0, s.targetTop = 0, s.appendBase = function() {
+        if (!s.resizable || !s.window)
+          return null;
+        var f = s.parentNode;
+        if (!f)
+          return null;
+        var u = s.window.document.createElement("div");
+        return u.style.width = "100%", u.style.height = "100%", u.style.position = "absolute", u.style.transform = "scale(0, 0)", u.style.left = "0", u.style.flex = "0 0 100%", u.classList ? u.classList.add(ut) : u.className += ut, f.appendChild(u), u;
+      }, s.removeBase = function(f) {
+        var u = s.parentNode;
+        u && u.removeChild(f);
+      }, s.state = {
+        isResizing: !1,
+        width: (n = (r = s.propsSize) === null || r === void 0 ? void 0 : r.width) !== null && n !== void 0 ? n : "auto",
+        height: (a = (o = s.propsSize) === null || o === void 0 ? void 0 : o.height) !== null && a !== void 0 ? a : "auto",
+        direction: "right",
+        original: {
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0
+        },
+        backgroundStyle: {
+          height: "100%",
+          width: "100%",
+          backgroundColor: "rgba(0,0,0,0)",
+          cursor: "auto",
+          opacity: 0,
+          position: "fixed",
+          zIndex: 9999,
+          top: "0",
+          left: "0",
+          bottom: "0",
+          right: "0"
+        },
+        flexBasis: void 0
+      }, s.onResizeStart = s.onResizeStart.bind(s), s.onMouseMove = s.onMouseMove.bind(s), s.onMouseUp = s.onMouseUp.bind(s), s;
+    }
+    return Object.defineProperty(i.prototype, "parentNode", {
+      get: function() {
+        return this.resizable ? this.resizable.parentNode : null;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(i.prototype, "window", {
+      get: function() {
+        return !this.resizable || !this.resizable.ownerDocument ? null : this.resizable.ownerDocument.defaultView;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(i.prototype, "propsSize", {
+      get: function() {
+        return this.props.size || this.props.defaultSize || Tr;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(i.prototype, "size", {
+      get: function() {
+        var t = 0, r = 0;
+        if (this.resizable && this.window) {
+          var n = this.resizable.offsetWidth, o = this.resizable.offsetHeight, a = this.resizable.style.position;
+          a !== "relative" && (this.resizable.style.position = "relative"), t = this.resizable.style.width !== "auto" ? this.resizable.offsetWidth : n, r = this.resizable.style.height !== "auto" ? this.resizable.offsetHeight : o, this.resizable.style.position = a;
+        }
+        return { width: t, height: r };
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(i.prototype, "sizeStyle", {
+      get: function() {
+        var t = this, r = this.props.size, n = function(s) {
+          var f;
+          if (typeof t.state[s] > "u" || t.state[s] === "auto")
+            return "auto";
+          if (t.propsSize && t.propsSize[s] && (!((f = t.propsSize[s]) === null || f === void 0) && f.toString().endsWith("%"))) {
+            if (t.state[s].toString().endsWith("%"))
+              return t.state[s].toString();
+            var u = t.getParentSize(), p = Number(t.state[s].toString().replace("px", "")), g = p / u[s] * 100;
+            return g + "%";
+          }
+          return ke(t.state[s]);
+        }, o = r && typeof r.width < "u" && !this.state.isResizing ? ke(r.width) : n("width"), a = r && typeof r.height < "u" && !this.state.isResizing ? ke(r.height) : n("height");
+        return { width: o, height: a };
+      },
+      enumerable: !1,
+      configurable: !0
+    }), i.prototype.getParentSize = function() {
+      if (!this.parentNode)
+        return this.window ? { width: this.window.innerWidth, height: this.window.innerHeight } : { width: 0, height: 0 };
+      var t = this.appendBase();
+      if (!t)
+        return { width: 0, height: 0 };
+      var r = !1, n = this.parentNode.style.flexWrap;
+      n !== "wrap" && (r = !0, this.parentNode.style.flexWrap = "wrap"), t.style.position = "relative", t.style.minWidth = "100%", t.style.minHeight = "100%";
+      var o = {
+        width: t.offsetWidth,
+        height: t.offsetHeight
+      };
+      return r && (this.parentNode.style.flexWrap = n), this.removeBase(t), o;
+    }, i.prototype.bindEvents = function() {
+      this.window && (this.window.addEventListener("mouseup", this.onMouseUp), this.window.addEventListener("mousemove", this.onMouseMove), this.window.addEventListener("mouseleave", this.onMouseUp), this.window.addEventListener("touchmove", this.onMouseMove, {
+        capture: !0,
+        passive: !1
+      }), this.window.addEventListener("touchend", this.onMouseUp));
+    }, i.prototype.unbindEvents = function() {
+      this.window && (this.window.removeEventListener("mouseup", this.onMouseUp), this.window.removeEventListener("mousemove", this.onMouseMove), this.window.removeEventListener("mouseleave", this.onMouseUp), this.window.removeEventListener("touchmove", this.onMouseMove, !0), this.window.removeEventListener("touchend", this.onMouseUp));
+    }, i.prototype.componentDidMount = function() {
+      if (!(!this.resizable || !this.window)) {
+        var t = this.window.getComputedStyle(this.resizable);
+        this.setState({
+          width: this.state.width || this.size.width,
+          height: this.state.height || this.size.height,
+          flexBasis: t.flexBasis !== "auto" ? t.flexBasis : void 0
+        });
+      }
+    }, i.prototype.componentWillUnmount = function() {
+      this.window && this.unbindEvents();
+    }, i.prototype.createSizeForCssProperty = function(t, r) {
+      var n = this.propsSize && this.propsSize[r];
+      return this.state[r] === "auto" && this.state.original[r] === t && (typeof n > "u" || n === "auto") ? "auto" : t;
+    }, i.prototype.calculateNewMaxFromBoundary = function(t, r) {
+      var n = this.props.boundsByDirection, o = this.state.direction, a = n && ge("left", o), s = n && ge("top", o), f, u;
+      if (this.props.bounds === "parent") {
+        var p = this.parentNode;
+        p && (f = a ? this.resizableRight - this.parentLeft : p.offsetWidth + (this.parentLeft - this.resizableLeft), u = s ? this.resizableBottom - this.parentTop : p.offsetHeight + (this.parentTop - this.resizableTop));
+      } else this.props.bounds === "window" ? this.window && (f = a ? this.resizableRight : this.window.innerWidth - this.resizableLeft, u = s ? this.resizableBottom : this.window.innerHeight - this.resizableTop) : this.props.bounds && (f = a ? this.resizableRight - this.targetLeft : this.props.bounds.offsetWidth + (this.targetLeft - this.resizableLeft), u = s ? this.resizableBottom - this.targetTop : this.props.bounds.offsetHeight + (this.targetTop - this.resizableTop));
+      return f && Number.isFinite(f) && (t = t && t < f ? t : f), u && Number.isFinite(u) && (r = r && r < u ? r : u), { maxWidth: t, maxHeight: r };
+    }, i.prototype.calculateNewSizeFromDirection = function(t, r) {
+      var n = this.props.scale || 1, o = Mr(this.props.resizeRatio || 1), a = o[0], s = o[1], f = this.state, u = f.direction, p = f.original, g = this.props, b = g.lockAspectRatio, S = g.lockAspectRatioExtraHeight, z = g.lockAspectRatioExtraWidth, w = p.width, E = p.height, D = S || 0, y = z || 0;
+      return ge("right", u) && (w = p.width + (t - p.x) * a / n, b && (E = (w - y) / this.ratio + D)), ge("left", u) && (w = p.width - (t - p.x) * a / n, b && (E = (w - y) / this.ratio + D)), ge("bottom", u) && (E = p.height + (r - p.y) * s / n, b && (w = (E - D) * this.ratio + y)), ge("top", u) && (E = p.height - (r - p.y) * s / n, b && (w = (E - D) * this.ratio + y)), { newWidth: w, newHeight: E };
+    }, i.prototype.calculateNewSizeFromAspectRatio = function(t, r, n, o) {
+      var a = this.props, s = a.lockAspectRatio, f = a.lockAspectRatioExtraHeight, u = a.lockAspectRatioExtraWidth, p = typeof o.width > "u" ? 10 : o.width, g = typeof n.width > "u" || n.width < 0 ? t : n.width, b = typeof o.height > "u" ? 10 : o.height, S = typeof n.height > "u" || n.height < 0 ? r : n.height, z = f || 0, w = u || 0;
+      if (s) {
+        var E = (b - z) * this.ratio + w, D = (S - z) * this.ratio + w, y = (p - w) / this.ratio + z, h = (g - w) / this.ratio + z, d = Math.max(p, E), l = Math.min(g, D), R = Math.max(b, y), x = Math.min(S, h);
+        t = xe(t, d, l), r = xe(r, R, x);
+      } else
+        t = xe(t, p, g), r = xe(r, b, S);
+      return { newWidth: t, newHeight: r };
+    }, i.prototype.setBoundingClientRect = function() {
+      if (this.props.bounds === "parent") {
+        var t = this.parentNode;
+        if (t) {
+          var r = t.getBoundingClientRect();
+          this.parentLeft = r.left, this.parentTop = r.top;
+        }
+      }
+      if (this.props.bounds && typeof this.props.bounds != "string") {
+        var n = this.props.bounds.getBoundingClientRect();
+        this.targetLeft = n.left, this.targetTop = n.top;
+      }
+      if (this.resizable) {
+        var o = this.resizable.getBoundingClientRect(), a = o.left, s = o.top, f = o.right, u = o.bottom;
+        this.resizableLeft = a, this.resizableRight = f, this.resizableTop = s, this.resizableBottom = u;
+      }
+    }, i.prototype.onResizeStart = function(t, r) {
+      if (!(!this.resizable || !this.window)) {
+        var n = 0, o = 0;
+        if (t.nativeEvent && Cr(t.nativeEvent) ? (n = t.nativeEvent.clientX, o = t.nativeEvent.clientY) : t.nativeEvent && ze(t.nativeEvent) && (n = t.nativeEvent.touches[0].clientX, o = t.nativeEvent.touches[0].clientY), this.props.onResizeStart && this.resizable) {
+          var a = this.props.onResizeStart(t, r, this.resizable);
+          if (a === !1)
+            return;
+        }
+        this.props.size && (typeof this.props.size.height < "u" && this.props.size.height !== this.state.height && this.setState({ height: this.props.size.height }), typeof this.props.size.width < "u" && this.props.size.width !== this.state.width && this.setState({ width: this.props.size.width })), this.ratio = typeof this.props.lockAspectRatio == "number" ? this.props.lockAspectRatio : this.size.width / this.size.height;
+        var s, f = this.window.getComputedStyle(this.resizable);
+        if (f.flexBasis !== "auto") {
+          var u = this.parentNode;
+          if (u) {
+            var p = this.window.getComputedStyle(u).flexDirection;
+            this.flexDir = p.startsWith("row") ? "row" : "column", s = f.flexBasis;
+          }
+        }
+        this.setBoundingClientRect(), this.bindEvents();
+        var g = {
+          original: {
+            x: n,
+            y: o,
+            width: this.size.width,
+            height: this.size.height
+          },
+          isResizing: !0,
+          backgroundStyle: ae(ae({}, this.state.backgroundStyle), { cursor: this.window.getComputedStyle(t.target).cursor || "auto" }),
+          direction: r,
+          flexBasis: s
+        };
+        this.setState(g);
+      }
+    }, i.prototype.onMouseMove = function(t) {
+      var r = this;
+      if (!(!this.state.isResizing || !this.resizable || !this.window)) {
+        if (this.window.TouchEvent && ze(t))
+          try {
+            t.preventDefault(), t.stopPropagation();
+          } catch {
+          }
+        var n = this.props, o = n.maxWidth, a = n.maxHeight, s = n.minWidth, f = n.minHeight, u = ze(t) ? t.touches[0].clientX : t.clientX, p = ze(t) ? t.touches[0].clientY : t.clientY, g = this.state, b = g.direction, S = g.original, z = g.width, w = g.height, E = this.getParentSize(), D = Or(E, this.window.innerWidth, this.window.innerHeight, o, a, s, f);
+        o = D.maxWidth, a = D.maxHeight, s = D.minWidth, f = D.minHeight;
+        var y = this.calculateNewSizeFromDirection(u, p), h = y.newHeight, d = y.newWidth, l = this.calculateNewMaxFromBoundary(o, a);
+        this.props.snap && this.props.snap.x && (d = lt(d, this.props.snap.x, this.props.snapGap)), this.props.snap && this.props.snap.y && (h = lt(h, this.props.snap.y, this.props.snapGap));
+        var R = this.calculateNewSizeFromAspectRatio(d, h, { width: l.maxWidth, height: l.maxHeight }, { width: s, height: f });
+        if (d = R.newWidth, h = R.newHeight, this.props.grid) {
+          var x = at(d, this.props.grid[0]), k = at(h, this.props.grid[1]), B = this.props.snapGap || 0, Y = B === 0 || Math.abs(x - d) <= B ? x : d, X = B === 0 || Math.abs(k - h) <= B ? k : h;
+          d = Y, h = X;
+        }
+        var j = {
+          width: d - S.width,
+          height: h - S.height
+        };
+        if (z && typeof z == "string") {
+          if (z.endsWith("%")) {
+            var q = d / E.width * 100;
+            d = q + "%";
+          } else if (z.endsWith("vw")) {
+            var V = d / this.window.innerWidth * 100;
+            d = V + "vw";
+          } else if (z.endsWith("vh")) {
+            var ie = d / this.window.innerHeight * 100;
+            d = ie + "vh";
+          }
+        }
+        if (w && typeof w == "string") {
+          if (w.endsWith("%")) {
+            var q = h / E.height * 100;
+            h = q + "%";
+          } else if (w.endsWith("vw")) {
+            var V = h / this.window.innerWidth * 100;
+            h = V + "vw";
+          } else if (w.endsWith("vh")) {
+            var ie = h / this.window.innerHeight * 100;
+            h = ie + "vh";
+          }
+        }
+        var I = {
+          width: this.createSizeForCssProperty(d, "width"),
+          height: this.createSizeForCssProperty(h, "height")
+        };
+        this.flexDir === "row" ? I.flexBasis = I.width : this.flexDir === "column" && (I.flexBasis = I.height);
+        var Z = this.state.width !== I.width, ne = this.state.height !== I.height, K = this.state.flexBasis !== I.flexBasis, c = Z || ne || K;
+        c && Tt(function() {
+          r.setState(I);
+        }), this.props.onResize && c && this.props.onResize(t, b, this.resizable, j);
+      }
+    }, i.prototype.onMouseUp = function(t) {
+      var r, n, o = this.state, a = o.isResizing, s = o.direction, f = o.original;
+      if (!(!a || !this.resizable)) {
+        var u = {
+          width: this.size.width - f.width,
+          height: this.size.height - f.height
+        };
+        this.props.onResizeStop && this.props.onResizeStop(t, s, this.resizable, u), this.props.size && this.setState({ width: (r = this.props.size.width) !== null && r !== void 0 ? r : "auto", height: (n = this.props.size.height) !== null && n !== void 0 ? n : "auto" }), this.unbindEvents(), this.setState({
+          isResizing: !1,
+          backgroundStyle: ae(ae({}, this.state.backgroundStyle), { cursor: "auto" })
+        });
+      }
+    }, i.prototype.updateSize = function(t) {
+      var r, n;
+      this.setState({ width: (r = t.width) !== null && r !== void 0 ? r : "auto", height: (n = t.height) !== null && n !== void 0 ? n : "auto" });
+    }, i.prototype.renderResizer = function() {
+      var t = this, r = this.props, n = r.enable, o = r.handleStyles, a = r.handleClasses, s = r.handleWrapperStyle, f = r.handleWrapperClass, u = r.handleComponent;
+      if (!n)
+        return null;
+      var p = Object.keys(n).map(function(g) {
+        return n[g] !== !1 ? pe.createElement(_r, { key: g, direction: g, onResizeStart: t.onResizeStart, replaceStyles: o && o[g], className: a && a[g] }, u && u[g] ? u[g] : null) : null;
+      });
+      return pe.createElement("div", { className: f, style: s }, p);
+    }, i.prototype.render = function() {
+      var t = this, r = Object.keys(this.props).reduce(function(a, s) {
+        return Wr.indexOf(s) !== -1 || (a[s] = t.props[s]), a;
+      }, {}), n = ae(ae(ae({ position: "relative", userSelect: this.state.isResizing ? "none" : "auto" }, this.props.style), this.sizeStyle), { maxWidth: this.props.maxWidth, maxHeight: this.props.maxHeight, minWidth: this.props.minWidth, minHeight: this.props.minHeight, boxSizing: "border-box", flexShrink: 0 });
+      this.state.flexBasis && (n.flexBasis = this.state.flexBasis);
+      var o = this.props.as || "div";
+      return pe.createElement(
+        o,
+        ae({ style: n, className: this.props.className }, r, {
+          // `ref` is after `extendsProps` to ensure this one wins over a version
+          // passed in
+          ref: function(a) {
+            a && (t.resizable = a);
+          }
+        }),
+        this.state.isResizing && pe.createElement("div", { style: this.state.backgroundStyle }),
+        this.props.children,
+        this.renderResizer()
+      );
+    }, i.defaultProps = {
+      as: "div",
+      onResizeStart: function() {
+      },
+      onResize: function() {
+      },
+      onResizeStop: function() {
+      },
+      enable: {
+        top: !0,
+        right: !0,
+        bottom: !0,
+        left: !0,
+        topRight: !0,
+        bottomRight: !0,
+        bottomLeft: !0,
+        topLeft: !0
+      },
+      style: {},
+      grid: [1, 1],
+      lockAspectRatio: !1,
+      lockAspectRatioExtraWidth: 0,
+      lockAspectRatioExtraHeight: 0,
+      scale: 1,
+      resizeRatio: 1,
+      snapGap: 0
+    }, i;
+  }(pe.PureComponent)
+);
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+var Ie = function(e, i) {
+  return Ie = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t, r) {
+    t.__proto__ = r;
+  } || function(t, r) {
+    for (var n in r) r.hasOwnProperty(n) && (t[n] = r[n]);
+  }, Ie(e, i);
+};
+function Nr(e, i) {
+  Ie(e, i);
+  function t() {
+    this.constructor = e;
+  }
+  e.prototype = i === null ? Object.create(i) : (t.prototype = i.prototype, new t());
+}
+var U = function() {
+  return U = Object.assign || function(i) {
+    for (var t, r = 1, n = arguments.length; r < n; r++) {
+      t = arguments[r];
+      for (var o in t) Object.prototype.hasOwnProperty.call(t, o) && (i[o] = t[o]);
+    }
+    return i;
+  }, U.apply(this, arguments);
+};
+function Hr(e, i) {
+  var t = {};
+  for (var r in e) Object.prototype.hasOwnProperty.call(e, r) && i.indexOf(r) < 0 && (t[r] = e[r]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var n = 0, r = Object.getOwnPropertySymbols(e); n < r.length; n++)
+      i.indexOf(r[n]) < 0 && Object.prototype.propertyIsEnumerable.call(e, r[n]) && (t[r[n]] = e[r[n]]);
+  return t;
+}
+var Lr = {
+  width: "auto",
+  height: "auto",
+  display: "inline-block",
+  position: "absolute",
+  top: 0,
+  left: 0
+}, kr = function(e) {
+  return {
+    bottom: e,
+    bottomLeft: e,
+    bottomRight: e,
+    left: e,
+    right: e,
+    top: e,
+    topLeft: e,
+    topRight: e
+  };
+}, jr = (
+  /** @class */
+  function(e) {
+    Nr(i, e);
+    function i(t) {
+      var r = e.call(this, t) || this;
+      return r.resizingPosition = { x: 0, y: 0 }, r.offsetFromParent = { left: 0, top: 0 }, r.resizableElement = { current: null }, r.originalPosition = { x: 0, y: 0 }, r.state = {
+        resizing: !1,
+        bounds: {
+          top: 0,
+          right: 0,
+          bottom: 0,
+          left: 0
+        },
+        maxWidth: t.maxWidth,
+        maxHeight: t.maxHeight
+      }, r.onResizeStart = r.onResizeStart.bind(r), r.onResize = r.onResize.bind(r), r.onResizeStop = r.onResizeStop.bind(r), r.onDragStart = r.onDragStart.bind(r), r.onDrag = r.onDrag.bind(r), r.onDragStop = r.onDragStop.bind(r), r.getMaxSizesFromProps = r.getMaxSizesFromProps.bind(r), r;
+    }
+    return i.prototype.componentDidMount = function() {
+      this.updateOffsetFromParent();
+      var t = this.offsetFromParent, r = t.left, n = t.top, o = this.getDraggablePosition(), a = o.x, s = o.y;
+      this.draggable.setState({
+        x: a - r,
+        y: s - n
+      }), this.forceUpdate();
+    }, i.prototype.getDraggablePosition = function() {
+      var t = this.draggable.state, r = t.x, n = t.y;
+      return { x: r, y: n };
+    }, i.prototype.getParent = function() {
+      return this.resizable && this.resizable.parentNode;
+    }, i.prototype.getParentSize = function() {
+      return this.resizable.getParentSize();
+    }, i.prototype.getMaxSizesFromProps = function() {
+      var t = typeof this.props.maxWidth > "u" ? Number.MAX_SAFE_INTEGER : this.props.maxWidth, r = typeof this.props.maxHeight > "u" ? Number.MAX_SAFE_INTEGER : this.props.maxHeight;
+      return { maxWidth: t, maxHeight: r };
+    }, i.prototype.getSelfElement = function() {
+      return this.resizable && this.resizable.resizable;
+    }, i.prototype.getOffsetHeight = function(t) {
+      var r = this.props.scale;
+      switch (this.props.bounds) {
+        case "window":
+          return window.innerHeight / r;
+        case "body":
+          return document.body.offsetHeight / r;
+        default:
+          return t.offsetHeight;
+      }
+    }, i.prototype.getOffsetWidth = function(t) {
+      var r = this.props.scale;
+      switch (this.props.bounds) {
+        case "window":
+          return window.innerWidth / r;
+        case "body":
+          return document.body.offsetWidth / r;
+        default:
+          return t.offsetWidth;
+      }
+    }, i.prototype.onDragStart = function(t, r) {
+      this.props.onDragStart && this.props.onDragStart(t, r);
+      var n = this.getDraggablePosition();
+      if (this.originalPosition = n, !!this.props.bounds) {
+        var o = this.getParent(), a = this.props.scale, s;
+        if (this.props.bounds === "parent")
+          s = o;
+        else if (this.props.bounds === "body") {
+          var f = o.getBoundingClientRect(), u = f.left, p = f.top, g = document.body.getBoundingClientRect(), b = -(u - o.offsetLeft * a - g.left) / a, S = -(p - o.offsetTop * a - g.top) / a, z = (document.body.offsetWidth - this.resizable.size.width * a) / a + b, w = (document.body.offsetHeight - this.resizable.size.height * a) / a + S;
+          return this.setState({ bounds: { top: S, right: z, bottom: w, left: b } });
+        } else if (this.props.bounds === "window") {
+          if (!this.resizable)
+            return;
+          var E = o.getBoundingClientRect(), D = E.left, y = E.top, h = -(D - o.offsetLeft * a) / a, d = -(y - o.offsetTop * a) / a, z = (window.innerWidth - this.resizable.size.width * a) / a + h, w = (window.innerHeight - this.resizable.size.height * a) / a + d;
+          return this.setState({ bounds: { top: d, right: z, bottom: w, left: h } });
+        } else typeof this.props.bounds == "string" ? s = document.querySelector(this.props.bounds) : this.props.bounds instanceof HTMLElement && (s = this.props.bounds);
+        if (!(!(s instanceof HTMLElement) || !(o instanceof HTMLElement))) {
+          var l = s.getBoundingClientRect(), R = l.left, x = l.top, k = o.getBoundingClientRect(), B = k.left, Y = k.top, X = (R - B) / a, j = x - Y;
+          if (this.resizable) {
+            this.updateOffsetFromParent();
+            var q = this.offsetFromParent;
+            this.setState({
+              bounds: {
+                top: j - q.top,
+                right: X + (s.offsetWidth - this.resizable.size.width) - q.left / a,
+                bottom: j + (s.offsetHeight - this.resizable.size.height) - q.top,
+                left: X - q.left / a
+              }
+            });
+          }
+        }
+      }
+    }, i.prototype.onDrag = function(t, r) {
+      if (this.props.onDrag) {
+        var n = this.offsetFromParent, o = n.left, a = n.top;
+        if (!this.props.dragAxis || this.props.dragAxis === "both")
+          return this.props.onDrag(t, U(U({}, r), { x: r.x + o, y: r.y + a }));
+        if (this.props.dragAxis === "x")
+          return this.props.onDrag(t, U(U({}, r), { x: r.x + o, y: this.originalPosition.y + a, deltaY: 0 }));
+        if (this.props.dragAxis === "y")
+          return this.props.onDrag(t, U(U({}, r), { x: this.originalPosition.x + o, y: r.y + a, deltaX: 0 }));
+      }
+    }, i.prototype.onDragStop = function(t, r) {
+      if (this.props.onDragStop) {
+        var n = this.offsetFromParent, o = n.left, a = n.top;
+        if (!this.props.dragAxis || this.props.dragAxis === "both")
+          return this.props.onDragStop(t, U(U({}, r), { x: r.x + o, y: r.y + a }));
+        if (this.props.dragAxis === "x")
+          return this.props.onDragStop(t, U(U({}, r), { x: r.x + o, y: this.originalPosition.y + a, deltaY: 0 }));
+        if (this.props.dragAxis === "y")
+          return this.props.onDragStop(t, U(U({}, r), { x: this.originalPosition.x + o, y: r.y + a, deltaX: 0 }));
+      }
+    }, i.prototype.onResizeStart = function(t, r, n) {
+      t.stopPropagation(), this.setState({
+        resizing: !0
+      });
+      var o = this.props.scale, a = this.offsetFromParent, s = this.getDraggablePosition();
+      if (this.resizingPosition = { x: s.x + a.left, y: s.y + a.top }, this.originalPosition = s, this.props.bounds) {
+        var f = this.getParent(), u = void 0;
+        this.props.bounds === "parent" ? u = f : this.props.bounds === "body" ? u = document.body : this.props.bounds === "window" ? u = window : typeof this.props.bounds == "string" ? u = document.querySelector(this.props.bounds) : this.props.bounds instanceof HTMLElement && (u = this.props.bounds);
+        var p = this.getSelfElement();
+        if (p instanceof Element && (u instanceof HTMLElement || u === window) && f instanceof HTMLElement) {
+          var g = this.getMaxSizesFromProps(), b = g.maxWidth, S = g.maxHeight, z = this.getParentSize();
+          if (b && typeof b == "string")
+            if (b.endsWith("%")) {
+              var w = Number(b.replace("%", "")) / 100;
+              b = z.width * w;
+            } else b.endsWith("px") && (b = Number(b.replace("px", "")));
+          if (S && typeof S == "string")
+            if (S.endsWith("%")) {
+              var w = Number(S.replace("%", "")) / 100;
+              S = z.height * w;
+            } else S.endsWith("px") && (S = Number(S.replace("px", "")));
+          var E = p.getBoundingClientRect(), D = E.left, y = E.top, h = this.props.bounds === "window" ? { left: 0, top: 0 } : u.getBoundingClientRect(), d = h.left, l = h.top, R = this.getOffsetWidth(u), x = this.getOffsetHeight(u), k = r.toLowerCase().endsWith("left"), B = r.toLowerCase().endsWith("right"), Y = r.startsWith("top"), X = r.startsWith("bottom");
+          if ((k || Y) && this.resizable) {
+            var j = (D - d) / o + this.resizable.size.width;
+            this.setState({ maxWidth: j > Number(b) ? b : j });
+          }
+          if (B || this.props.lockAspectRatio && !k && !Y) {
+            var j = R + (d - D) / o;
+            this.setState({ maxWidth: j > Number(b) ? b : j });
+          }
+          if ((Y || k) && this.resizable) {
+            var j = (y - l) / o + this.resizable.size.height;
+            this.setState({
+              maxHeight: j > Number(S) ? S : j
+            });
+          }
+          if (X || this.props.lockAspectRatio && !Y && !k) {
+            var j = x + (l - y) / o;
+            this.setState({
+              maxHeight: j > Number(S) ? S : j
+            });
+          }
+        }
+      } else
+        this.setState({
+          maxWidth: this.props.maxWidth,
+          maxHeight: this.props.maxHeight
+        });
+      this.props.onResizeStart && this.props.onResizeStart(t, r, n);
+    }, i.prototype.onResize = function(t, r, n, o) {
+      var a = { x: this.originalPosition.x, y: this.originalPosition.y }, s = -o.width, f = -o.height, u = ["top", "left", "topLeft", "bottomLeft", "topRight"];
+      u.includes(r) && (r === "bottomLeft" ? a.x += s : (r === "topRight" || (a.x += s), a.y += f));
+      var p = this.draggable.state;
+      (a.x !== p.x || a.y !== p.y) && this.draggable.setState(a), this.updateOffsetFromParent();
+      var g = this.offsetFromParent, b = this.getDraggablePosition().x + g.left, S = this.getDraggablePosition().y + g.top;
+      this.resizingPosition = { x: b, y: S }, this.props.onResize && this.props.onResize(t, r, n, o, {
+        x: b,
+        y: S
+      });
+    }, i.prototype.onResizeStop = function(t, r, n, o) {
+      this.setState({
+        resizing: !1
+      });
+      var a = this.getMaxSizesFromProps(), s = a.maxWidth, f = a.maxHeight;
+      this.setState({ maxWidth: s, maxHeight: f }), this.props.onResizeStop && this.props.onResizeStop(t, r, n, o, this.resizingPosition);
+    }, i.prototype.updateSize = function(t) {
+      this.resizable && this.resizable.updateSize({ width: t.width, height: t.height });
+    }, i.prototype.updatePosition = function(t) {
+      this.draggable.setState(t);
+    }, i.prototype.updateOffsetFromParent = function() {
+      var t = this.props.scale, r = this.getParent(), n = this.getSelfElement();
+      if (!r || n === null)
+        return {
+          top: 0,
+          left: 0
+        };
+      var o = r.getBoundingClientRect(), a = o.left, s = o.top, f = n.getBoundingClientRect(), u = this.getDraggablePosition(), p = r.scrollLeft, g = r.scrollTop;
+      this.offsetFromParent = {
+        left: f.left - a + p - u.x * t,
+        top: f.top - s + g - u.y * t
+      };
+    }, i.prototype.render = function() {
+      var t = this, r = this.props, n = r.disableDragging, o = r.style, a = r.dragHandleClassName, s = r.position, f = r.onMouseDown, u = r.onMouseUp, p = r.dragAxis, g = r.dragGrid, b = r.bounds, S = r.enableUserSelectHack, z = r.cancel, w = r.children;
+      r.onResizeStart, r.onResize, r.onResizeStop, r.onDragStart, r.onDrag, r.onDragStop;
+      var E = r.resizeHandleStyles, D = r.resizeHandleClasses, y = r.resizeHandleComponent, h = r.enableResizing, d = r.resizeGrid, l = r.resizeHandleWrapperClass, R = r.resizeHandleWrapperStyle, x = r.scale, k = r.allowAnyClick, B = Hr(r, ["disableDragging", "style", "dragHandleClassName", "position", "onMouseDown", "onMouseUp", "dragAxis", "dragGrid", "bounds", "enableUserSelectHack", "cancel", "children", "onResizeStart", "onResize", "onResizeStop", "onDragStart", "onDrag", "onDragStop", "resizeHandleStyles", "resizeHandleClasses", "resizeHandleComponent", "enableResizing", "resizeGrid", "resizeHandleWrapperClass", "resizeHandleWrapperStyle", "scale", "allowAnyClick"]), Y = this.props.default ? U({}, this.props.default) : void 0;
+      delete B.default;
+      var X = n || a ? { cursor: "auto" } : { cursor: "move" }, j = U(U(U({}, Lr), X), o), q = this.offsetFromParent, V = q.left, ie = q.top, I;
+      s && (I = {
+        x: s.x - V,
+        y: s.y - ie
+      });
+      var Z = this.state.resizing ? void 0 : I, ne = this.state.resizing ? "both" : p;
+      return qe(
+        Er,
+        {
+          ref: function(K) {
+            K && (t.draggable = K);
+          },
+          handle: a ? ".".concat(a) : void 0,
+          defaultPosition: Y,
+          onMouseDown: f,
+          // @ts-expect-error
+          onMouseUp: u,
+          onStart: this.onDragStart,
+          onDrag: this.onDrag,
+          onStop: this.onDragStop,
+          axis: ne,
+          disabled: n,
+          grid: g,
+          bounds: b ? this.state.bounds : void 0,
+          position: Z,
+          enableUserSelectHack: S,
+          cancel: z,
+          scale: x,
+          allowAnyClick: k,
+          nodeRef: this.resizableElement
+        },
+        qe(Ar, U({}, B, { ref: function(K) {
+          K && (t.resizable = K, t.resizableElement.current = K.resizable);
+        }, defaultSize: Y, size: this.props.size, enable: typeof h == "boolean" ? kr(h) : h, onResizeStart: this.onResizeStart, onResize: this.onResize, onResizeStop: this.onResizeStop, style: j, minWidth: this.props.minWidth, minHeight: this.props.minHeight, maxWidth: this.state.resizing ? this.state.maxWidth : this.props.maxWidth, maxHeight: this.state.resizing ? this.state.maxHeight : this.props.maxHeight, grid: d, handleWrapperClass: l, handleWrapperStyle: R, lockAspectRatio: this.props.lockAspectRatio, lockAspectRatioExtraWidth: this.props.lockAspectRatioExtraWidth, lockAspectRatioExtraHeight: this.props.lockAspectRatioExtraHeight, handleStyles: E, handleClasses: D, handleComponent: y, scale: this.props.scale }), w)
+      );
+    }, i.defaultProps = {
+      maxWidth: Number.MAX_SAFE_INTEGER,
+      maxHeight: Number.MAX_SAFE_INTEGER,
+      scale: 1,
+      onResizeStart: function() {
+      },
+      onResize: function() {
+      },
+      onResizeStop: function() {
+      },
+      onDragStart: function() {
+      },
+      onDrag: function() {
+      },
+      onDragStop: function() {
+      }
+    }, i;
+  }(Pt)
+), Ir = /* @__PURE__ */ ((e) => (e[e.truePositive = 0] = "truePositive", e[e.falsePositive = 1] = "falsePositive", e[e.suggestion = 2] = "suggestion", e))(Ir || {});
+const Yr = {
+  0: "#84cc16",
+  1: "#cc2216",
+  2: "#84cc16"
+}, $r = {
+  0: "#ffffff",
+  1: "#c95d55",
+  2: "#3dd8ff"
+}, Vr = (e) => {
+  const [i, t] = Rt(e.initialScale ?? 1);
+  Ct(({ state: o }) => {
+    t(o.scale);
+  });
+  let r = e.selected ? Yr[e.type] : $r[e.type];
+  const n = e.type !== 1;
+  return e.difficult && (r = e.selected ? "#fae352" : "#ad9e3d"), /* @__PURE__ */ Xe(
+    jr,
+    {
+      className: `${e.className ?? ""} border-solid`,
+      style: {
+        zIndex: e.zIndex,
+        borderColor: r,
+        borderWidth: 2 * (1 / i)
+      },
+      bounds: "parent",
+      scale: i,
+      position: {
+        x: e.x,
+        y: e.y
+      },
+      size: {
+        width: e.w,
+        height: e.h
+      },
+      onDragStop: e.onDragStop,
+      onResizeStop: e.onResizeStop,
+      disableDragging: !n,
+      enableResizing: n,
+      onMouseDown: e.onMouseDown,
+      children: [
+        /* @__PURE__ */ he(
+          "mark",
+          {
+            className: `absolute bottom-[-25px] right-[-2px] ${e.type === 1 ? "line-through" : ""} decoration-2`,
+            style: {
+              backgroundColor: r,
+              transform: `scale(${(1 / i).toString()})`,
+              transformOrigin: "top right"
+            },
+            children: e.label
+          }
+        ),
+        /* @__PURE__ */ Xe(
+          "div",
+          {
+            className: "absolute right-[-27px] z-20 grid grid-rows-1",
+            style: {
+              visibility: e.selected ? "visible" : "hidden",
+              transform: `scale(${(1 / i).toString()})`,
+              transformOrigin: "top left",
+              top: -13 * (1 / i)
+            },
+            children: [
+              /* @__PURE__ */ he(
+                "div",
+                {
+                  className: "flex h-6 w-6 flex-shrink-0 cursor-pointer items-center justify-center rounded-full bg-red-400",
+                  onClick: e.onClickDelete,
+                  children: /* @__PURE__ */ he(
+                    "svg",
+                    {
+                      xmlns: "http://www.w3.org/2000/svg",
+                      className: "h-6 w-6",
+                      fill: "none",
+                      viewBox: "0 0 24 24",
+                      stroke: "currentColor",
+                      children: /* @__PURE__ */ he(
+                        "path",
+                        {
+                          strokeLinecap: "round",
+                          strokeLinejoin: "round",
+                          strokeWidth: "2",
+                          d: "M18 12H6"
+                        }
+                      )
+                    }
+                  )
+                }
+              ),
+              n && /* @__PURE__ */ he(
+                "div",
+                {
+                  className: "flex h-6 w-6 flex-shrink-0 cursor-pointer items-center justify-center rounded-full bg-blue-400",
+                  onClick: e.onClickEdit,
+                  children: /* @__PURE__ */ he(
+                    "svg",
+                    {
+                      xmlns: "http://www.w3.org/2000/svg",
+                      className: "h-4 w-4",
+                      fill: "none",
+                      viewBox: "0 0 24 24",
+                      stroke: "currentColor",
+                      children: /* @__PURE__ */ he(
+                        "path",
+                        {
+                          strokeLinecap: "round",
+                          strokeLinejoin: "round",
+                          strokeWidth: "2",
+                          d: "M15.232 5.232l3.536 3.536m-2.036-5.036a2.5 2.5 0 113.536 3.536L6.5 21.036H3v-3.572L16.732 3.732z"
+                        }
+                      )
+                    }
+                  )
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+export {
+  Vr as BoundingBox,
+  Ir as BoundingBoxType
+};
+//# sourceMappingURL=BoundingBox.js.map