react-table-edit 0.8.2 → 0.8.3

package/dist/index.mjs

@@ -1,3 +1,3037 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/react-is/cjs/react-is.production.min.js
+var require_react_is_production_min = __commonJS({
+  "node_modules/react-is/cjs/react-is.production.min.js"(exports) {
+    "use strict";
+    var b = "function" === typeof Symbol && Symbol.for;
+    var c = b ? Symbol.for("react.element") : 60103;
+    var d = b ? Symbol.for("react.portal") : 60106;
+    var e = b ? Symbol.for("react.fragment") : 60107;
+    var f = b ? Symbol.for("react.strict_mode") : 60108;
+    var g = b ? Symbol.for("react.profiler") : 60114;
+    var h = b ? Symbol.for("react.provider") : 60109;
+    var k = b ? Symbol.for("react.context") : 60110;
+    var l = b ? Symbol.for("react.async_mode") : 60111;
+    var m = b ? Symbol.for("react.concurrent_mode") : 60111;
+    var n = b ? Symbol.for("react.forward_ref") : 60112;
+    var p = b ? Symbol.for("react.suspense") : 60113;
+    var q = b ? Symbol.for("react.suspense_list") : 60120;
+    var r2 = b ? Symbol.for("react.memo") : 60115;
+    var t = b ? Symbol.for("react.lazy") : 60116;
+    var v = b ? Symbol.for("react.block") : 60121;
+    var w = b ? Symbol.for("react.fundamental") : 60117;
+    var x = b ? Symbol.for("react.responder") : 60118;
+    var y = b ? Symbol.for("react.scope") : 60119;
+    function z(a) {
+      if ("object" === typeof a && null !== a) {
+        var u = a.$$typeof;
+        switch (u) {
+          case c:
+            switch (a = a.type, a) {
+              case l:
+              case m:
+              case e:
+              case g:
+              case f:
+              case p:
+                return a;
+              default:
+                switch (a = a && a.$$typeof, a) {
+                  case k:
+                  case n:
+                  case t:
+                  case r2:
+                  case h:
+                    return a;
+                  default:
+                    return u;
+                }
+            }
+          case d:
+            return u;
+        }
+      }
+    }
+    function A(a) {
+      return z(a) === m;
+    }
+    exports.AsyncMode = l;
+    exports.ConcurrentMode = m;
+    exports.ContextConsumer = k;
+    exports.ContextProvider = h;
+    exports.Element = c;
+    exports.ForwardRef = n;
+    exports.Fragment = e;
+    exports.Lazy = t;
+    exports.Memo = r2;
+    exports.Portal = d;
+    exports.Profiler = g;
+    exports.StrictMode = f;
+    exports.Suspense = p;
+    exports.isAsyncMode = function(a) {
+      return A(a) || z(a) === l;
+    };
+    exports.isConcurrentMode = A;
+    exports.isContextConsumer = function(a) {
+      return z(a) === k;
+    };
+    exports.isContextProvider = function(a) {
+      return z(a) === h;
+    };
+    exports.isElement = function(a) {
+      return "object" === typeof a && null !== a && a.$$typeof === c;
+    };
+    exports.isForwardRef = function(a) {
+      return z(a) === n;
+    };
+    exports.isFragment = function(a) {
+      return z(a) === e;
+    };
+    exports.isLazy = function(a) {
+      return z(a) === t;
+    };
+    exports.isMemo = function(a) {
+      return z(a) === r2;
+    };
+    exports.isPortal = function(a) {
+      return z(a) === d;
+    };
+    exports.isProfiler = function(a) {
+      return z(a) === g;
+    };
+    exports.isStrictMode = function(a) {
+      return z(a) === f;
+    };
+    exports.isSuspense = function(a) {
+      return z(a) === p;
+    };
+    exports.isValidElementType = function(a) {
+      return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r2 || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
+    };
+    exports.typeOf = z;
+  }
+});
+
+// node_modules/react-is/cjs/react-is.development.js
+var require_react_is_development = __commonJS({
+  "node_modules/react-is/cjs/react-is.development.js"(exports) {
+    "use strict";
+    if (process.env.NODE_ENV !== "production") {
+      (function() {
+        "use strict";
+        var hasSymbol = typeof Symbol === "function" && Symbol.for;
+        var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103;
+        var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106;
+        var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for("react.fragment") : 60107;
+        var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for("react.strict_mode") : 60108;
+        var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for("react.profiler") : 60114;
+        var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for("react.provider") : 60109;
+        var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110;
+        var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111;
+        var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for("react.concurrent_mode") : 60111;
+        var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112;
+        var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for("react.suspense") : 60113;
+        var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for("react.suspense_list") : 60120;
+        var REACT_MEMO_TYPE = hasSymbol ? Symbol.for("react.memo") : 60115;
+        var REACT_LAZY_TYPE = hasSymbol ? Symbol.for("react.lazy") : 60116;
+        var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for("react.block") : 60121;
+        var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for("react.fundamental") : 60117;
+        var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for("react.responder") : 60118;
+        var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for("react.scope") : 60119;
+        function isValidElementType(type) {
+          return typeof type === "string" || typeof type === "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+          type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+        }
+        function typeOf(object) {
+          if (typeof object === "object" && object !== null) {
+            var $$typeof = object.$$typeof;
+            switch ($$typeof) {
+              case REACT_ELEMENT_TYPE:
+                var type = object.type;
+                switch (type) {
+                  case REACT_ASYNC_MODE_TYPE:
+                  case REACT_CONCURRENT_MODE_TYPE:
+                  case REACT_FRAGMENT_TYPE:
+                  case REACT_PROFILER_TYPE:
+                  case REACT_STRICT_MODE_TYPE:
+                  case REACT_SUSPENSE_TYPE:
+                    return type;
+                  default:
+                    var $$typeofType = type && type.$$typeof;
+                    switch ($$typeofType) {
+                      case REACT_CONTEXT_TYPE:
+                      case REACT_FORWARD_REF_TYPE:
+                      case REACT_LAZY_TYPE:
+                      case REACT_MEMO_TYPE:
+                      case REACT_PROVIDER_TYPE:
+                        return $$typeofType;
+                      default:
+                        return $$typeof;
+                    }
+                }
+              case REACT_PORTAL_TYPE:
+                return $$typeof;
+            }
+          }
+          return void 0;
+        }
+        var AsyncMode = REACT_ASYNC_MODE_TYPE;
+        var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+        var ContextConsumer = REACT_CONTEXT_TYPE;
+        var ContextProvider = REACT_PROVIDER_TYPE;
+        var Element = REACT_ELEMENT_TYPE;
+        var ForwardRef = REACT_FORWARD_REF_TYPE;
+        var Fragment21 = REACT_FRAGMENT_TYPE;
+        var Lazy = REACT_LAZY_TYPE;
+        var Memo = REACT_MEMO_TYPE;
+        var Portal = REACT_PORTAL_TYPE;
+        var Profiler = REACT_PROFILER_TYPE;
+        var StrictMode = REACT_STRICT_MODE_TYPE;
+        var Suspense = REACT_SUSPENSE_TYPE;
+        var hasWarnedAboutDeprecatedIsAsyncMode = false;
+        function isAsyncMode(object) {
+          {
+            if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+              hasWarnedAboutDeprecatedIsAsyncMode = true;
+              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.");
+            }
+          }
+          return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+        }
+        function isConcurrentMode(object) {
+          return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+        }
+        function isContextConsumer(object) {
+          return typeOf(object) === REACT_CONTEXT_TYPE;
+        }
+        function isContextProvider(object) {
+          return typeOf(object) === REACT_PROVIDER_TYPE;
+        }
+        function isElement(object) {
+          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+        }
+        function isForwardRef(object) {
+          return typeOf(object) === REACT_FORWARD_REF_TYPE;
+        }
+        function isFragment(object) {
+          return typeOf(object) === REACT_FRAGMENT_TYPE;
+        }
+        function isLazy(object) {
+          return typeOf(object) === REACT_LAZY_TYPE;
+        }
+        function isMemo(object) {
+          return typeOf(object) === REACT_MEMO_TYPE;
+        }
+        function isPortal(object) {
+          return typeOf(object) === REACT_PORTAL_TYPE;
+        }
+        function isProfiler(object) {
+          return typeOf(object) === REACT_PROFILER_TYPE;
+        }
+        function isStrictMode(object) {
+          return typeOf(object) === REACT_STRICT_MODE_TYPE;
+        }
+        function isSuspense(object) {
+          return typeOf(object) === REACT_SUSPENSE_TYPE;
+        }
+        exports.AsyncMode = AsyncMode;
+        exports.ConcurrentMode = ConcurrentMode;
+        exports.ContextConsumer = ContextConsumer;
+        exports.ContextProvider = ContextProvider;
+        exports.Element = Element;
+        exports.ForwardRef = ForwardRef;
+        exports.Fragment = Fragment21;
+        exports.Lazy = Lazy;
+        exports.Memo = Memo;
+        exports.Portal = Portal;
+        exports.Profiler = Profiler;
+        exports.StrictMode = StrictMode;
+        exports.Suspense = Suspense;
+        exports.isAsyncMode = isAsyncMode;
+        exports.isConcurrentMode = isConcurrentMode;
+        exports.isContextConsumer = isContextConsumer;
+        exports.isContextProvider = isContextProvider;
+        exports.isElement = isElement;
+        exports.isForwardRef = isForwardRef;
+        exports.isFragment = isFragment;
+        exports.isLazy = isLazy;
+        exports.isMemo = isMemo;
+        exports.isPortal = isPortal;
+        exports.isProfiler = isProfiler;
+        exports.isStrictMode = isStrictMode;
+        exports.isSuspense = isSuspense;
+        exports.isValidElementType = isValidElementType;
+        exports.typeOf = typeOf;
+      })();
+    }
+  }
+});
+
+// node_modules/react-is/index.js
+var require_react_is = __commonJS({
+  "node_modules/react-is/index.js"(exports, module) {
+    "use strict";
+    if (process.env.NODE_ENV === "production") {
+      module.exports = require_react_is_production_min();
+    } else {
+      module.exports = require_react_is_development();
+    }
+  }
+});
+
+// node_modules/object-assign/index.js
+var require_object_assign = __commonJS({
+  "node_modules/object-assign/index.js"(exports, module) {
+    "use strict";
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+    function toObject(val) {
+      if (val === null || val === void 0) {
+        throw new TypeError("Object.assign cannot be called with null or undefined");
+      }
+      return Object(val);
+    }
+    function shouldUseNative() {
+      try {
+        if (!Object.assign) {
+          return false;
+        }
+        var test1 = new String("abc");
+        test1[5] = "de";
+        if (Object.getOwnPropertyNames(test1)[0] === "5") {
+          return false;
+        }
+        var test2 = {};
+        for (var i = 0; i < 10; i++) {
+          test2["_" + String.fromCharCode(i)] = i;
+        }
+        var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
+          return test2[n];
+        });
+        if (order2.join("") !== "0123456789") {
+          return false;
+        }
+        var test3 = {};
+        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+          test3[letter] = letter;
+        });
+        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+          return false;
+        }
+        return true;
+      } catch (err) {
+        return false;
+      }
+    }
+    module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+      var from;
+      var to = toObject(target);
+      var symbols;
+      for (var s = 1; s < arguments.length; s++) {
+        from = Object(arguments[s]);
+        for (var key in from) {
+          if (hasOwnProperty.call(from, key)) {
+            to[key] = from[key];
+          }
+        }
+        if (getOwnPropertySymbols) {
+          symbols = getOwnPropertySymbols(from);
+          for (var i = 0; i < symbols.length; i++) {
+            if (propIsEnumerable.call(from, symbols[i])) {
+              to[symbols[i]] = from[symbols[i]];
+            }
+          }
+        }
+      }
+      return to;
+    };
+  }
+});
+
+// node_modules/prop-types/lib/ReactPropTypesSecret.js
+var require_ReactPropTypesSecret = __commonJS({
+  "node_modules/prop-types/lib/ReactPropTypesSecret.js"(exports, module) {
+    "use strict";
+    var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+    module.exports = ReactPropTypesSecret;
+  }
+});
+
+// node_modules/prop-types/lib/has.js
+var require_has = __commonJS({
+  "node_modules/prop-types/lib/has.js"(exports, module) {
+    "use strict";
+    module.exports = Function.call.bind(Object.prototype.hasOwnProperty);
+  }
+});
+
+// node_modules/prop-types/checkPropTypes.js
+var require_checkPropTypes = __commonJS({
+  "node_modules/prop-types/checkPropTypes.js"(exports, module) {
+    "use strict";
+    var printWarning = function() {
+    };
+    if (process.env.NODE_ENV !== "production") {
+      ReactPropTypesSecret = require_ReactPropTypesSecret();
+      loggedTypeFailures = {};
+      has = require_has();
+      printWarning = function(text) {
+        var message = "Warning: " + text;
+        if (typeof console !== "undefined") {
+          console.error(message);
+        }
+        try {
+          throw new Error(message);
+        } catch (x) {
+        }
+      };
+    }
+    var ReactPropTypesSecret;
+    var loggedTypeFailures;
+    var has;
+    function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+      if (process.env.NODE_ENV !== "production") {
+        for (var typeSpecName in typeSpecs) {
+          if (has(typeSpecs, typeSpecName)) {
+            var error;
+            try {
+              if (typeof typeSpecs[typeSpecName] !== "function") {
+                var err = Error(
+                  (componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+                );
+                err.name = "Invariant Violation";
+                throw err;
+              }
+              error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+            } catch (ex) {
+              error = ex;
+            }
+            if (error && !(error instanceof Error)) {
+              printWarning(
+                (componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof error + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+              );
+            }
+            if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+              loggedTypeFailures[error.message] = true;
+              var stack = getStack ? getStack() : "";
+              printWarning(
+                "Failed " + location + " type: " + error.message + (stack != null ? stack : "")
+              );
+            }
+          }
+        }
+      }
+    }
+    checkPropTypes.resetWarningCache = function() {
+      if (process.env.NODE_ENV !== "production") {
+        loggedTypeFailures = {};
+      }
+    };
+    module.exports = checkPropTypes;
+  }
+});
+
+// node_modules/prop-types/factoryWithTypeCheckers.js
+var require_factoryWithTypeCheckers = __commonJS({
+  "node_modules/prop-types/factoryWithTypeCheckers.js"(exports, module) {
+    "use strict";
+    var ReactIs = require_react_is();
+    var assign = require_object_assign();
+    var ReactPropTypesSecret = require_ReactPropTypesSecret();
+    var has = require_has();
+    var checkPropTypes = require_checkPropTypes();
+    var printWarning = function() {
+    };
+    if (process.env.NODE_ENV !== "production") {
+      printWarning = function(text) {
+        var message = "Warning: " + text;
+        if (typeof console !== "undefined") {
+          console.error(message);
+        }
+        try {
+          throw new Error(message);
+        } catch (x) {
+        }
+      };
+    }
+    function emptyFunctionThatReturnsNull() {
+      return null;
+    }
+    module.exports = function(isValidElement, throwOnDirectAccess) {
+      var ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
+      var FAUX_ITERATOR_SYMBOL = "@@iterator";
+      function getIteratorFn(maybeIterable) {
+        var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+        if (typeof iteratorFn === "function") {
+          return iteratorFn;
+        }
+      }
+      var ANONYMOUS = "<<anonymous>>";
+      var ReactPropTypes = {
+        array: createPrimitiveTypeChecker("array"),
+        bigint: createPrimitiveTypeChecker("bigint"),
+        bool: createPrimitiveTypeChecker("boolean"),
+        func: createPrimitiveTypeChecker("function"),
+        number: createPrimitiveTypeChecker("number"),
+        object: createPrimitiveTypeChecker("object"),
+        string: createPrimitiveTypeChecker("string"),
+        symbol: createPrimitiveTypeChecker("symbol"),
+        any: createAnyTypeChecker(),
+        arrayOf: createArrayOfTypeChecker,
+        element: createElementTypeChecker(),
+        elementType: createElementTypeTypeChecker(),
+        instanceOf: createInstanceTypeChecker,
+        node: createNodeChecker(),
+        objectOf: createObjectOfTypeChecker,
+        oneOf: createEnumTypeChecker,
+        oneOfType: createUnionTypeChecker,
+        shape: createShapeTypeChecker,
+        exact: createStrictShapeTypeChecker
+      };
+      function is(x, y) {
+        if (x === y) {
+          return x !== 0 || 1 / x === 1 / y;
+        } else {
+          return x !== x && y !== y;
+        }
+      }
+      function PropTypeError(message, data) {
+        this.message = message;
+        this.data = data && typeof data === "object" ? data : {};
+        this.stack = "";
+      }
+      PropTypeError.prototype = Error.prototype;
+      function createChainableTypeChecker(validate) {
+        if (process.env.NODE_ENV !== "production") {
+          var manualPropTypeCallCache = {};
+          var manualPropTypeWarningCount = 0;
+        }
+        function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+          componentName = componentName || ANONYMOUS;
+          propFullName = propFullName || propName;
+          if (secret !== ReactPropTypesSecret) {
+            if (throwOnDirectAccess) {
+              var err = 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"
+              );
+              err.name = "Invariant Violation";
+              throw err;
+            } else if (process.env.NODE_ENV !== "production" && typeof console !== "undefined") {
+              var cacheKey = componentName + ":" + propName;
+              if (!manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors
+              manualPropTypeWarningCount < 3) {
+                printWarning(
+                  "You are manually calling a React.PropTypes validation function for the `" + propFullName + "` prop on `" + componentName + "`. 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."
+                );
+                manualPropTypeCallCache[cacheKey] = true;
+                manualPropTypeWarningCount++;
+              }
+            }
+          }
+          if (props[propName] == null) {
+            if (isRequired) {
+              if (props[propName] === null) {
+                return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required " + ("in `" + componentName + "`, but its value is `null`."));
+              }
+              return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required in " + ("`" + componentName + "`, but its value is `undefined`."));
+            }
+            return null;
+          } else {
+            return validate(props, propName, componentName, location, propFullName);
+          }
+        }
+        var chainedCheckType = checkType.bind(null, false);
+        chainedCheckType.isRequired = checkType.bind(null, true);
+        return chainedCheckType;
+      }
+      function createPrimitiveTypeChecker(expectedType) {
+        function validate(props, propName, componentName, location, propFullName, secret) {
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== expectedType) {
+            var preciseType = getPreciseType(propValue);
+            return new PropTypeError(
+              "Invalid " + location + " `" + propFullName + "` of type " + ("`" + preciseType + "` supplied to `" + componentName + "`, expected ") + ("`" + expectedType + "`."),
+              { expectedType }
+            );
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createAnyTypeChecker() {
+        return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+      }
+      function createArrayOfTypeChecker(typeChecker) {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (typeof typeChecker !== "function") {
+            return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf.");
+          }
+          var propValue = props[propName];
+          if (!Array.isArray(propValue)) {
+            var propType = getPropType(propValue);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an array."));
+          }
+          for (var i = 0; i < propValue.length; i++) {
+            var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret);
+            if (error instanceof Error) {
+              return error;
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createElementTypeChecker() {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          if (!isValidElement(propValue)) {
+            var propType = getPropType(propValue);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createElementTypeTypeChecker() {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          if (!ReactIs.isValidElementType(propValue)) {
+            var propType = getPropType(propValue);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement type."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createInstanceTypeChecker(expectedClass) {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (!(props[propName] instanceof expectedClass)) {
+            var expectedClassName = expectedClass.name || ANONYMOUS;
+            var actualClassName = getClassName(props[propName]);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createEnumTypeChecker(expectedValues) {
+        if (!Array.isArray(expectedValues)) {
+          if (process.env.NODE_ENV !== "production") {
+            if (arguments.length > 1) {
+              printWarning(
+                "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])."
+              );
+            } else {
+              printWarning("Invalid argument supplied to oneOf, expected an array.");
+            }
+          }
+          return emptyFunctionThatReturnsNull;
+        }
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          for (var i = 0; i < expectedValues.length; i++) {
+            if (is(propValue, expectedValues[i])) {
+              return null;
+            }
+          }
+          var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+            var type = getPreciseType(value);
+            if (type === "symbol") {
+              return String(value);
+            }
+            return value;
+          });
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + String(propValue) + "` " + ("supplied to `" + componentName + "`, expected one of " + valuesString + "."));
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createObjectOfTypeChecker(typeChecker) {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (typeof typeChecker !== "function") {
+            return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf.");
+          }
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== "object") {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an object."));
+          }
+          for (var key in propValue) {
+            if (has(propValue, key)) {
+              var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+              if (error instanceof Error) {
+                return error;
+              }
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createUnionTypeChecker(arrayOfTypeCheckers) {
+        if (!Array.isArray(arrayOfTypeCheckers)) {
+          process.env.NODE_ENV !== "production" ? printWarning("Invalid argument supplied to oneOfType, expected an instance of array.") : void 0;
+          return emptyFunctionThatReturnsNull;
+        }
+        for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+          var checker = arrayOfTypeCheckers[i];
+          if (typeof checker !== "function") {
+            printWarning(
+              "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + " at index " + i + "."
+            );
+            return emptyFunctionThatReturnsNull;
+          }
+        }
+        function validate(props, propName, componentName, location, propFullName) {
+          var expectedTypes = [];
+          for (var i2 = 0; i2 < arrayOfTypeCheckers.length; i2++) {
+            var checker2 = arrayOfTypeCheckers[i2];
+            var checkerResult = checker2(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+            if (checkerResult == null) {
+              return null;
+            }
+            if (checkerResult.data && has(checkerResult.data, "expectedType")) {
+              expectedTypes.push(checkerResult.data.expectedType);
+            }
+          }
+          var expectedTypesMessage = expectedTypes.length > 0 ? ", expected one of type [" + expectedTypes.join(", ") + "]" : "";
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`" + expectedTypesMessage + "."));
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createNodeChecker() {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (!isNode(props[propName])) {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`, expected a ReactNode."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function invalidValidatorError(componentName, location, propFullName, key, type) {
+        return new PropTypeError(
+          (componentName || "React class") + ": " + location + " type `" + propFullName + "." + key + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + type + "`."
+        );
+      }
+      function createShapeTypeChecker(shapeTypes) {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== "object") {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+          }
+          for (var key in shapeTypes) {
+            var checker = shapeTypes[key];
+            if (typeof checker !== "function") {
+              return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+            }
+            var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+            if (error) {
+              return error;
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createStrictShapeTypeChecker(shapeTypes) {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== "object") {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+          }
+          var allKeys = assign({}, props[propName], shapeTypes);
+          for (var key in allKeys) {
+            var checker = shapeTypes[key];
+            if (has(shapeTypes, key) && typeof checker !== "function") {
+              return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+            }
+            if (!checker) {
+              return new PropTypeError(
+                "Invalid " + location + " `" + propFullName + "` key `" + key + "` supplied to `" + componentName + "`.\nBad object: " + JSON.stringify(props[propName], null, "  ") + "\nValid keys: " + JSON.stringify(Object.keys(shapeTypes), null, "  ")
+              );
+            }
+            var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+            if (error) {
+              return error;
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function isNode(propValue) {
+        switch (typeof propValue) {
+          case "number":
+          case "string":
+          case "undefined":
+            return true;
+          case "boolean":
+            return !propValue;
+          case "object":
+            if (Array.isArray(propValue)) {
+              return propValue.every(isNode);
+            }
+            if (propValue === null || isValidElement(propValue)) {
+              return true;
+            }
+            var iteratorFn = getIteratorFn(propValue);
+            if (iteratorFn) {
+              var iterator = iteratorFn.call(propValue);
+              var step;
+              if (iteratorFn !== propValue.entries) {
+                while (!(step = iterator.next()).done) {
+                  if (!isNode(step.value)) {
+                    return false;
+                  }
+                }
+              } else {
+                while (!(step = iterator.next()).done) {
+                  var entry = step.value;
+                  if (entry) {
+                    if (!isNode(entry[1])) {
+                      return false;
+                    }
+                  }
+                }
+              }
+            } else {
+              return false;
+            }
+            return true;
+          default:
+            return false;
+        }
+      }
+      function isSymbol(propType, propValue) {
+        if (propType === "symbol") {
+          return true;
+        }
+        if (!propValue) {
+          return false;
+        }
+        if (propValue["@@toStringTag"] === "Symbol") {
+          return true;
+        }
+        if (typeof Symbol === "function" && propValue instanceof Symbol) {
+          return true;
+        }
+        return false;
+      }
+      function getPropType(propValue) {
+        var propType = typeof propValue;
+        if (Array.isArray(propValue)) {
+          return "array";
+        }
+        if (propValue instanceof RegExp) {
+          return "object";
+        }
+        if (isSymbol(propType, propValue)) {
+          return "symbol";
+        }
+        return propType;
+      }
+      function getPreciseType(propValue) {
+        if (typeof propValue === "undefined" || propValue === null) {
+          return "" + propValue;
+        }
+        var propType = getPropType(propValue);
+        if (propType === "object") {
+          if (propValue instanceof Date) {
+            return "date";
+          } else if (propValue instanceof RegExp) {
+            return "regexp";
+          }
+        }
+        return propType;
+      }
+      function getPostfixForTypeWarning(value) {
+        var type = getPreciseType(value);
+        switch (type) {
+          case "array":
+          case "object":
+            return "an " + type;
+          case "boolean":
+          case "date":
+          case "regexp":
+            return "a " + type;
+          default:
+            return type;
+        }
+      }
+      function getClassName(propValue) {
+        if (!propValue.constructor || !propValue.constructor.name) {
+          return ANONYMOUS;
+        }
+        return propValue.constructor.name;
+      }
+      ReactPropTypes.checkPropTypes = checkPropTypes;
+      ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+      ReactPropTypes.PropTypes = ReactPropTypes;
+      return ReactPropTypes;
+    };
+  }
+});
+
+// node_modules/prop-types/factoryWithThrowingShims.js
+var require_factoryWithThrowingShims = __commonJS({
+  "node_modules/prop-types/factoryWithThrowingShims.js"(exports, module) {
+    "use strict";
+    var ReactPropTypesSecret = require_ReactPropTypesSecret();
+    function emptyFunction() {
+    }
+    function emptyFunctionWithReset() {
+    }
+    emptyFunctionWithReset.resetWarningCache = emptyFunction;
+    module.exports = function() {
+      function shim(props, propName, componentName, location, propFullName, secret) {
+        if (secret === ReactPropTypesSecret) {
+          return;
+        }
+        var err = 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"
+        );
+        err.name = "Invariant Violation";
+        throw err;
+      }
+      ;
+      shim.isRequired = shim;
+      function getShim() {
+        return shim;
+      }
+      ;
+      var ReactPropTypes = {
+        array: shim,
+        bigint: shim,
+        bool: shim,
+        func: shim,
+        number: shim,
+        object: shim,
+        string: shim,
+        symbol: shim,
+        any: shim,
+        arrayOf: getShim,
+        element: shim,
+        elementType: shim,
+        instanceOf: getShim,
+        node: shim,
+        objectOf: getShim,
+        oneOf: getShim,
+        oneOfType: getShim,
+        shape: getShim,
+        exact: getShim,
+        checkPropTypes: emptyFunctionWithReset,
+        resetWarningCache: emptyFunction
+      };
+      ReactPropTypes.PropTypes = ReactPropTypes;
+      return ReactPropTypes;
+    };
+  }
+});
+
+// node_modules/prop-types/index.js
+var require_prop_types = __commonJS({
+  "node_modules/prop-types/index.js"(exports, module) {
+    "use strict";
+    if (process.env.NODE_ENV !== "production") {
+      ReactIs = require_react_is();
+      throwOnDirectAccess = true;
+      module.exports = require_factoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
+    } else {
+      module.exports = require_factoryWithThrowingShims()();
+    }
+    var ReactIs;
+    var throwOnDirectAccess;
+  }
+});
+
+// node_modules/clsx/dist/clsx.m.js
+var clsx_m_exports = {};
+__export(clsx_m_exports, {
+  clsx: () => clsx,
+  default: () => clsx_m_default
+});
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e)
+    n += e;
+  else if ("object" == typeof e)
+    if (Array.isArray(e))
+      for (t = 0; t < e.length; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    else
+      for (t in e)
+        e[t] && (n && (n += " "), n += t);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = ""; f < arguments.length; )
+    (e = arguments[f++]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+var clsx_m_default;
+var init_clsx_m = __esm({
+  "node_modules/clsx/dist/clsx.m.js"() {
+    "use strict";
+    clsx_m_default = clsx;
+  }
+});
+
+// node_modules/react-draggable/build/cjs/utils/shims.js
+var require_shims = __commonJS({
+  "node_modules/react-draggable/build/cjs/utils/shims.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.dontSetMe = dontSetMe;
+    exports.findInArray = findInArray;
+    exports.int = int;
+    exports.isFunction = isFunction;
+    exports.isNum = isNum;
+    function findInArray(array, callback) {
+      for (let i = 0, length = array.length; i < length; i++) {
+        if (callback.apply(callback, [array[i], i, array]))
+          return array[i];
+      }
+    }
+    function isFunction(func) {
+      return typeof func === "function" || Object.prototype.toString.call(func) === "[object Function]";
+    }
+    function isNum(num) {
+      return typeof num === "number" && !isNaN(num);
+    }
+    function int(a) {
+      return parseInt(a, 10);
+    }
+    function dontSetMe(props, propName, componentName) {
+      if (props[propName]) {
+        return new Error("Invalid prop ".concat(propName, " passed to ").concat(componentName, " - do not set this, set it on the child."));
+      }
+    }
+  }
+});
+
+// node_modules/react-draggable/build/cjs/utils/getPrefix.js
+var require_getPrefix = __commonJS({
+  "node_modules/react-draggable/build/cjs/utils/getPrefix.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.browserPrefixToKey = browserPrefixToKey;
+    exports.browserPrefixToStyle = browserPrefixToStyle;
+    exports.default = void 0;
+    exports.getPrefix = getPrefix;
+    var prefixes = ["Moz", "Webkit", "O", "ms"];
+    function getPrefix() {
+      var _window$document;
+      let prop = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "transform";
+      if (typeof window === "undefined")
+        return "";
+      const style = (_window$document = window.document) === null || _window$document === void 0 || (_window$document = _window$document.documentElement) === null || _window$document === void 0 ? void 0 : _window$document.style;
+      if (!style)
+        return "";
+      if (prop in style)
+        return "";
+      for (let i = 0; i < prefixes.length; i++) {
+        if (browserPrefixToKey(prop, prefixes[i]) in style)
+          return prefixes[i];
+      }
+      return "";
+    }
+    function browserPrefixToKey(prop, prefix) {
+      return prefix ? "".concat(prefix).concat(kebabToTitleCase(prop)) : prop;
+    }
+    function browserPrefixToStyle(prop, prefix) {
+      return prefix ? "-".concat(prefix.toLowerCase(), "-").concat(prop) : prop;
+    }
+    function kebabToTitleCase(str) {
+      let out = "";
+      let shouldCapitalize = true;
+      for (let i = 0; i < str.length; i++) {
+        if (shouldCapitalize) {
+          out += str[i].toUpperCase();
+          shouldCapitalize = false;
+        } else if (str[i] === "-") {
+          shouldCapitalize = true;
+        } else {
+          out += str[i];
+        }
+      }
+      return out;
+    }
+    var _default = exports.default = getPrefix();
+  }
+});
+
+// node_modules/react-draggable/build/cjs/utils/domFns.js
+var require_domFns = __commonJS({
+  "node_modules/react-draggable/build/cjs/utils/domFns.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.addClassName = addClassName;
+    exports.addEvent = addEvent;
+    exports.addUserSelectStyles = addUserSelectStyles;
+    exports.createCSSTransform = createCSSTransform;
+    exports.createSVGTransform = createSVGTransform;
+    exports.getTouch = getTouch;
+    exports.getTouchIdentifier = getTouchIdentifier;
+    exports.getTranslation = getTranslation;
+    exports.innerHeight = innerHeight;
+    exports.innerWidth = innerWidth;
+    exports.matchesSelector = matchesSelector;
+    exports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;
+    exports.offsetXYFromParent = offsetXYFromParent;
+    exports.outerHeight = outerHeight;
+    exports.outerWidth = outerWidth;
+    exports.removeClassName = removeClassName;
+    exports.removeEvent = removeEvent;
+    exports.removeUserSelectStyles = removeUserSelectStyles;
+    var _shims = require_shims();
+    var _getPrefix = _interopRequireWildcard(require_getPrefix());
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function")
+        return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interopRequireWildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return { default: obj };
+      }
+      var cache = _getRequireWildcardCache(nodeInterop);
+      if (cache && cache.has(obj)) {
+        return cache.get(obj);
+      }
+      var newObj = {};
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj.default = obj;
+      if (cache) {
+        cache.set(obj, newObj);
+      }
+      return newObj;
+    }
+    var matchesSelectorFunc = "";
+    function matchesSelector(el, selector) {
+      if (!matchesSelectorFunc) {
+        matchesSelectorFunc = (0, _shims.findInArray)(["matches", "webkitMatchesSelector", "mozMatchesSelector", "msMatchesSelector", "oMatchesSelector"], function(method) {
+          return (0, _shims.isFunction)(el[method]);
+        });
+      }
+      if (!(0, _shims.isFunction)(el[matchesSelectorFunc]))
+        return false;
+      return el[matchesSelectorFunc](selector);
+    }
+    function matchesSelectorAndParentsTo(el, selector, baseNode) {
+      let node = el;
+      do {
+        if (matchesSelector(node, selector))
+          return true;
+        if (node === baseNode)
+          return false;
+        node = node.parentNode;
+      } while (node);
+      return false;
+    }
+    function addEvent(el, event, handler, inputOptions) {
+      if (!el)
+        return;
+      const options = {
+        capture: true,
+        ...inputOptions
+      };
+      if (el.addEventListener) {
+        el.addEventListener(event, handler, options);
+      } else if (el.attachEvent) {
+        el.attachEvent("on" + event, handler);
+      } else {
+        el["on" + event] = handler;
+      }
+    }
+    function removeEvent(el, event, handler, inputOptions) {
+      if (!el)
+        return;
+      const options = {
+        capture: true,
+        ...inputOptions
+      };
+      if (el.removeEventListener) {
+        el.removeEventListener(event, handler, options);
+      } else if (el.detachEvent) {
+        el.detachEvent("on" + event, handler);
+      } else {
+        el["on" + event] = null;
+      }
+    }
+    function outerHeight(node) {
+      let height = node.clientHeight;
+      const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+      height += (0, _shims.int)(computedStyle.borderTopWidth);
+      height += (0, _shims.int)(computedStyle.borderBottomWidth);
+      return height;
+    }
+    function outerWidth(node) {
+      let width = node.clientWidth;
+      const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+      width += (0, _shims.int)(computedStyle.borderLeftWidth);
+      width += (0, _shims.int)(computedStyle.borderRightWidth);
+      return width;
+    }
+    function innerHeight(node) {
+      let height = node.clientHeight;
+      const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+      height -= (0, _shims.int)(computedStyle.paddingTop);
+      height -= (0, _shims.int)(computedStyle.paddingBottom);
+      return height;
+    }
+    function innerWidth(node) {
+      let width = node.clientWidth;
+      const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+      width -= (0, _shims.int)(computedStyle.paddingLeft);
+      width -= (0, _shims.int)(computedStyle.paddingRight);
+      return width;
+    }
+    function offsetXYFromParent(evt, offsetParent, scale) {
+      const isBody = offsetParent === offsetParent.ownerDocument.body;
+      const offsetParentRect = isBody ? {
+        left: 0,
+        top: 0
+      } : offsetParent.getBoundingClientRect();
+      const x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;
+      const y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;
+      return {
+        x,
+        y
+      };
+    }
+    function createCSSTransform(controlPos, positionOffset) {
+      const translation = getTranslation(controlPos, positionOffset, "px");
+      return {
+        [(0, _getPrefix.browserPrefixToKey)("transform", _getPrefix.default)]: translation
+      };
+    }
+    function createSVGTransform(controlPos, positionOffset) {
+      const translation = getTranslation(controlPos, positionOffset, "");
+      return translation;
+    }
+    function getTranslation(_ref, positionOffset, unitSuffix) {
+      let {
+        x,
+        y
+      } = _ref;
+      let translation = "translate(".concat(x).concat(unitSuffix, ",").concat(y).concat(unitSuffix, ")");
+      if (positionOffset) {
+        const defaultX = "".concat(typeof positionOffset.x === "string" ? positionOffset.x : positionOffset.x + unitSuffix);
+        const defaultY = "".concat(typeof positionOffset.y === "string" ? positionOffset.y : positionOffset.y + unitSuffix);
+        translation = "translate(".concat(defaultX, ", ").concat(defaultY, ")") + translation;
+      }
+      return translation;
+    }
+    function getTouch(e, identifier) {
+      return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, (t) => identifier === t.identifier) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, (t) => identifier === t.identifier);
+    }
+    function getTouchIdentifier(e) {
+      if (e.targetTouches && e.targetTouches[0])
+        return e.targetTouches[0].identifier;
+      if (e.changedTouches && e.changedTouches[0])
+        return e.changedTouches[0].identifier;
+    }
+    function addUserSelectStyles(doc) {
+      if (!doc)
+        return;
+      let styleEl = doc.getElementById("react-draggable-style-el");
+      if (!styleEl) {
+        styleEl = doc.createElement("style");
+        styleEl.type = "text/css";
+        styleEl.id = "react-draggable-style-el";
+        styleEl.innerHTML = ".react-draggable-transparent-selection *::-moz-selection {all: inherit;}\n";
+        styleEl.innerHTML += ".react-draggable-transparent-selection *::selection {all: inherit;}\n";
+        doc.getElementsByTagName("head")[0].appendChild(styleEl);
+      }
+      if (doc.body)
+        addClassName(doc.body, "react-draggable-transparent-selection");
+    }
+    function removeUserSelectStyles(doc) {
+      if (!doc)
+        return;
+      try {
+        if (doc.body)
+          removeClassName(doc.body, "react-draggable-transparent-selection");
+        if (doc.selection) {
+          doc.selection.empty();
+        } else {
+          const selection = (doc.defaultView || window).getSelection();
+          if (selection && selection.type !== "Caret") {
+            selection.removeAllRanges();
+          }
+        }
+      } catch (e) {
+      }
+    }
+    function addClassName(el, className) {
+      if (el.classList) {
+        el.classList.add(className);
+      } else {
+        if (!el.className.match(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)")))) {
+          el.className += " ".concat(className);
+        }
+      }
+    }
+    function removeClassName(el, className) {
+      if (el.classList) {
+        el.classList.remove(className);
+      } else {
+        el.className = el.className.replace(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)"), "g"), "");
+      }
+    }
+  }
+});
+
+// node_modules/react-draggable/build/cjs/utils/positionFns.js
+var require_positionFns = __commonJS({
+  "node_modules/react-draggable/build/cjs/utils/positionFns.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.canDragX = canDragX;
+    exports.canDragY = canDragY;
+    exports.createCoreData = createCoreData;
+    exports.createDraggableData = createDraggableData;
+    exports.getBoundPosition = getBoundPosition;
+    exports.getControlPosition = getControlPosition;
+    exports.snapToGrid = snapToGrid;
+    var _shims = require_shims();
+    var _domFns = require_domFns();
+    function getBoundPosition(draggable, x, y) {
+      if (!draggable.props.bounds)
+        return [x, y];
+      let {
+        bounds
+      } = draggable.props;
+      bounds = typeof bounds === "string" ? bounds : cloneBounds(bounds);
+      const node = findDOMNode(draggable);
+      if (typeof bounds === "string") {
+        const {
+          ownerDocument
+        } = node;
+        const ownerWindow = ownerDocument.defaultView;
+        let boundNode;
+        if (bounds === "parent") {
+          boundNode = node.parentNode;
+        } else {
+          boundNode = ownerDocument.querySelector(bounds);
+        }
+        if (!(boundNode instanceof ownerWindow.HTMLElement)) {
+          throw new Error('Bounds selector "' + bounds + '" could not find an element.');
+        }
+        const boundNodeEl = boundNode;
+        const nodeStyle = ownerWindow.getComputedStyle(node);
+        const boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl);
+        bounds = {
+          left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),
+          top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),
+          right: (0, _domFns.innerWidth)(boundNodeEl) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),
+          bottom: (0, _domFns.innerHeight)(boundNodeEl) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)
+        };
+      }
+      if ((0, _shims.isNum)(bounds.right))
+        x = Math.min(x, bounds.right);
+      if ((0, _shims.isNum)(bounds.bottom))
+        y = Math.min(y, bounds.bottom);
+      if ((0, _shims.isNum)(bounds.left))
+        x = Math.max(x, bounds.left);
+      if ((0, _shims.isNum)(bounds.top))
+        y = Math.max(y, bounds.top);
+      return [x, y];
+    }
+    function snapToGrid(grid, pendingX, pendingY) {
+      const x = Math.round(pendingX / grid[0]) * grid[0];
+      const y = Math.round(pendingY / grid[1]) * grid[1];
+      return [x, y];
+    }
+    function canDragX(draggable) {
+      return draggable.props.axis === "both" || draggable.props.axis === "x";
+    }
+    function canDragY(draggable) {
+      return draggable.props.axis === "both" || draggable.props.axis === "y";
+    }
+    function getControlPosition(e, touchIdentifier, draggableCore) {
+      const touchObj = typeof touchIdentifier === "number" ? (0, _domFns.getTouch)(e, touchIdentifier) : null;
+      if (typeof touchIdentifier === "number" && !touchObj)
+        return null;
+      const node = findDOMNode(draggableCore);
+      const offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;
+      return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);
+    }
+    function createCoreData(draggable, x, y) {
+      const isStart = !(0, _shims.isNum)(draggable.lastX);
+      const node = findDOMNode(draggable);
+      if (isStart) {
+        return {
+          node,
+          deltaX: 0,
+          deltaY: 0,
+          lastX: x,
+          lastY: y,
+          x,
+          y
+        };
+      } else {
+        return {
+          node,
+          deltaX: x - draggable.lastX,
+          deltaY: y - draggable.lastY,
+          lastX: draggable.lastX,
+          lastY: draggable.lastY,
+          x,
+          y
+        };
+      }
+    }
+    function createDraggableData(draggable, coreData) {
+      const scale = draggable.props.scale;
+      return {
+        node: coreData.node,
+        x: draggable.state.x + coreData.deltaX / scale,
+        y: draggable.state.y + coreData.deltaY / scale,
+        deltaX: coreData.deltaX / scale,
+        deltaY: coreData.deltaY / scale,
+        lastX: draggable.state.x,
+        lastY: draggable.state.y
+      };
+    }
+    function cloneBounds(bounds) {
+      return {
+        left: bounds.left,
+        top: bounds.top,
+        right: bounds.right,
+        bottom: bounds.bottom
+      };
+    }
+    function findDOMNode(draggable) {
+      const node = draggable.findDOMNode();
+      if (!node) {
+        throw new Error("<DraggableCore>: Unmounted during event!");
+      }
+      return node;
+    }
+  }
+});
+
+// node_modules/react-draggable/build/cjs/utils/log.js
+var require_log = __commonJS({
+  "node_modules/react-draggable/build/cjs/utils/log.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = log;
+    function log() {
+      if (void 0)
+        console.log(...arguments);
+    }
+  }
+});
+
+// node_modules/react-draggable/build/cjs/DraggableCore.js
+var require_DraggableCore = __commonJS({
+  "node_modules/react-draggable/build/cjs/DraggableCore.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var React = _interopRequireWildcard(__require("react"));
+    var _propTypes = _interopRequireDefault(require_prop_types());
+    var _reactDom = _interopRequireDefault(__require("react-dom"));
+    var _domFns = require_domFns();
+    var _positionFns = require_positionFns();
+    var _shims = require_shims();
+    var _log = _interopRequireDefault(require_log());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function")
+        return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interopRequireWildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return { default: obj };
+      }
+      var cache = _getRequireWildcardCache(nodeInterop);
+      if (cache && cache.has(obj)) {
+        return cache.get(obj);
+      }
+      var newObj = {};
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj.default = obj;
+      if (cache) {
+        cache.set(obj, newObj);
+      }
+      return newObj;
+    }
+    function _defineProperty(obj, key, value) {
+      key = _toPropertyKey(key);
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return typeof key === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null)
+        return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (typeof res !== "object")
+          return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
+    var eventsFor = {
+      touch: {
+        start: "touchstart",
+        move: "touchmove",
+        stop: "touchend"
+      },
+      mouse: {
+        start: "mousedown",
+        move: "mousemove",
+        stop: "mouseup"
+      }
+    };
+    var dragEventFor = eventsFor.mouse;
+    var DraggableCore = class extends React.Component {
+      constructor() {
+        super(...arguments);
+        _defineProperty(this, "dragging", false);
+        _defineProperty(this, "lastX", NaN);
+        _defineProperty(this, "lastY", NaN);
+        _defineProperty(this, "touchIdentifier", null);
+        _defineProperty(this, "mounted", false);
+        _defineProperty(this, "handleDragStart", (e) => {
+          this.props.onMouseDown(e);
+          if (!this.props.allowAnyClick && typeof e.button === "number" && e.button !== 0)
+            return false;
+          const thisNode = this.findDOMNode();
+          if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {
+            throw new Error("<DraggableCore> not mounted on DragStart!");
+          }
+          const {
+            ownerDocument
+          } = thisNode;
+          if (this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, this.props.handle, thisNode) || this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, this.props.cancel, thisNode)) {
+            return;
+          }
+          if (e.type === "touchstart")
+            e.preventDefault();
+          const touchIdentifier = (0, _domFns.getTouchIdentifier)(e);
+          this.touchIdentifier = touchIdentifier;
+          const position = (0, _positionFns.getControlPosition)(e, touchIdentifier, this);
+          if (position == null)
+            return;
+          const {
+            x,
+            y
+          } = position;
+          const coreEvent = (0, _positionFns.createCoreData)(this, x, y);
+          (0, _log.default)("DraggableCore: handleDragStart: %j", coreEvent);
+          (0, _log.default)("calling", this.props.onStart);
+          const shouldUpdate = this.props.onStart(e, coreEvent);
+          if (shouldUpdate === false || this.mounted === false)
+            return;
+          if (this.props.enableUserSelectHack)
+            (0, _domFns.addUserSelectStyles)(ownerDocument);
+          this.dragging = true;
+          this.lastX = x;
+          this.lastY = y;
+          (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, this.handleDrag);
+          (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, this.handleDragStop);
+        });
+        _defineProperty(this, "handleDrag", (e) => {
+          const position = (0, _positionFns.getControlPosition)(e, this.touchIdentifier, this);
+          if (position == null)
+            return;
+          let {
+            x,
+            y
+          } = position;
+          if (Array.isArray(this.props.grid)) {
+            let deltaX = x - this.lastX, deltaY = y - this.lastY;
+            [deltaX, deltaY] = (0, _positionFns.snapToGrid)(this.props.grid, deltaX, deltaY);
+            if (!deltaX && !deltaY)
+              return;
+            x = this.lastX + deltaX, y = this.lastY + deltaY;
+          }
+          const coreEvent = (0, _positionFns.createCoreData)(this, x, y);
+          (0, _log.default)("DraggableCore: handleDrag: %j", coreEvent);
+          const shouldUpdate = this.props.onDrag(e, coreEvent);
+          if (shouldUpdate === false || this.mounted === false) {
+            try {
+              this.handleDragStop(new MouseEvent("mouseup"));
+            } catch (err) {
+              const event = document.createEvent("MouseEvents");
+              event.initMouseEvent("mouseup", true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+              this.handleDragStop(event);
+            }
+            return;
+          }
+          this.lastX = x;
+          this.lastY = y;
+        });
+        _defineProperty(this, "handleDragStop", (e) => {
+          if (!this.dragging)
+            return;
+          const position = (0, _positionFns.getControlPosition)(e, this.touchIdentifier, this);
+          if (position == null)
+            return;
+          let {
+            x,
+            y
+          } = position;
+          if (Array.isArray(this.props.grid)) {
+            let deltaX = x - this.lastX || 0;
+            let deltaY = y - this.lastY || 0;
+            [deltaX, deltaY] = (0, _positionFns.snapToGrid)(this.props.grid, deltaX, deltaY);
+            x = this.lastX + deltaX, y = this.lastY + deltaY;
+          }
+          const coreEvent = (0, _positionFns.createCoreData)(this, x, y);
+          const shouldContinue = this.props.onStop(e, coreEvent);
+          if (shouldContinue === false || this.mounted === false)
+            return false;
+          const thisNode = this.findDOMNode();
+          if (thisNode) {
+            if (this.props.enableUserSelectHack)
+              (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);
+          }
+          (0, _log.default)("DraggableCore: handleDragStop: %j", coreEvent);
+          this.dragging = false;
+          this.lastX = NaN;
+          this.lastY = NaN;
+          if (thisNode) {
+            (0, _log.default)("DraggableCore: Removing handlers");
+            (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, this.handleDrag);
+            (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, this.handleDragStop);
+          }
+        });
+        _defineProperty(this, "onMouseDown", (e) => {
+          dragEventFor = eventsFor.mouse;
+          return this.handleDragStart(e);
+        });
+        _defineProperty(this, "onMouseUp", (e) => {
+          dragEventFor = eventsFor.mouse;
+          return this.handleDragStop(e);
+        });
+        _defineProperty(this, "onTouchStart", (e) => {
+          dragEventFor = eventsFor.touch;
+          return this.handleDragStart(e);
+        });
+        _defineProperty(this, "onTouchEnd", (e) => {
+          dragEventFor = eventsFor.touch;
+          return this.handleDragStop(e);
+        });
+      }
+      componentDidMount() {
+        this.mounted = true;
+        const thisNode = this.findDOMNode();
+        if (thisNode) {
+          (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
+            passive: false
+          });
+        }
+      }
+      componentWillUnmount() {
+        this.mounted = false;
+        const thisNode = this.findDOMNode();
+        if (thisNode) {
+          const {
+            ownerDocument
+          } = thisNode;
+          (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);
+          (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);
+          (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);
+          (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);
+          (0, _domFns.removeEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {
+            passive: false
+          });
+          if (this.props.enableUserSelectHack)
+            (0, _domFns.removeUserSelectStyles)(ownerDocument);
+        }
+      }
+      // 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 _this$props, _this$props2;
+        return (_this$props = this.props) !== null && _this$props !== void 0 && _this$props.nodeRef ? (_this$props2 = this.props) === null || _this$props2 === void 0 || (_this$props2 = _this$props2.nodeRef) === null || _this$props2 === void 0 ? void 0 : _this$props2.current : _reactDom.default.findDOMNode(this);
+      }
+      render() {
+        return /* @__PURE__ */ React.cloneElement(React.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
+        });
+      }
+    };
+    exports.default = DraggableCore;
+    _defineProperty(DraggableCore, "displayName", "DraggableCore");
+    _defineProperty(DraggableCore, "propTypes", {
+      /**
+       * `allowAnyClick` allows dragging using any mouse button.
+       * By default, we only accept the left button.
+       *
+       * Defaults to `false`.
+       */
+      allowAnyClick: _propTypes.default.bool,
+      children: _propTypes.default.node.isRequired,
+      /**
+       * `disabled`, if true, stops the <Draggable> from dragging. All handlers,
+       * with the exception of `onMouseDown`, will not fire.
+       */
+      disabled: _propTypes.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: _propTypes.default.bool,
+      /**
+       * `offsetParent`, if set, uses the passed DOM node to compute drag offsets
+       * instead of using the parent node.
+       */
+      offsetParent: function(props, propName) {
+        if (props[propName] && props[propName].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: _propTypes.default.arrayOf(_propTypes.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: _propTypes.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: _propTypes.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: _propTypes.default.object,
+      /**
+       * Called when dragging starts.
+       * If this function returns the boolean false, dragging will be canceled.
+       */
+      onStart: _propTypes.default.func,
+      /**
+       * Called while dragging.
+       * If this function returns the boolean false, dragging will be canceled.
+       */
+      onDrag: _propTypes.default.func,
+      /**
+       * Called when dragging stops.
+       * If this function returns the boolean false, the drag will remain active.
+       */
+      onStop: _propTypes.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: _propTypes.default.func,
+      /**
+       * `scale`, if set, applies scaling while dragging an element
+       */
+      scale: _propTypes.default.number,
+      /**
+       * These properties should be defined on the child, not here.
+       */
+      className: _shims.dontSetMe,
+      style: _shims.dontSetMe,
+      transform: _shims.dontSetMe
+    });
+    _defineProperty(DraggableCore, "defaultProps", {
+      allowAnyClick: false,
+      // by default only accept left click
+      disabled: false,
+      enableUserSelectHack: true,
+      onStart: function() {
+      },
+      onDrag: function() {
+      },
+      onStop: function() {
+      },
+      onMouseDown: function() {
+      },
+      scale: 1
+    });
+  }
+});
+
+// node_modules/react-draggable/build/cjs/Draggable.js
+var require_Draggable = __commonJS({
+  "node_modules/react-draggable/build/cjs/Draggable.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "DraggableCore", {
+      enumerable: true,
+      get: function() {
+        return _DraggableCore.default;
+      }
+    });
+    exports.default = void 0;
+    var React = _interopRequireWildcard(__require("react"));
+    var _propTypes = _interopRequireDefault(require_prop_types());
+    var _reactDom = _interopRequireDefault(__require("react-dom"));
+    var _clsx = _interopRequireDefault((init_clsx_m(), __toCommonJS(clsx_m_exports)));
+    var _domFns = require_domFns();
+    var _positionFns = require_positionFns();
+    var _shims = require_shims();
+    var _DraggableCore = _interopRequireDefault(require_DraggableCore());
+    var _log = _interopRequireDefault(require_log());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function")
+        return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interopRequireWildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return { default: obj };
+      }
+      var cache = _getRequireWildcardCache(nodeInterop);
+      if (cache && cache.has(obj)) {
+        return cache.get(obj);
+      }
+      var newObj = {};
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj.default = obj;
+      if (cache) {
+        cache.set(obj, newObj);
+      }
+      return newObj;
+    }
+    function _extends() {
+      _extends = Object.assign ? Object.assign.bind() : function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    function _defineProperty(obj, key, value) {
+      key = _toPropertyKey(key);
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return typeof key === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null)
+        return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (typeof res !== "object")
+          return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
+    var Draggable = class extends React.Component {
+      // React 16.3+
+      // Arity (props, state)
+      static getDerivedStateFromProps(_ref, _ref2) {
+        let {
+          position
+        } = _ref;
+        let {
+          prevPropsPosition
+        } = _ref2;
+        if (position && (!prevPropsPosition || position.x !== prevPropsPosition.x || position.y !== prevPropsPosition.y)) {
+          (0, _log.default)("Draggable: getDerivedStateFromProps %j", {
+            position,
+            prevPropsPosition
+          });
+          return {
+            x: position.x,
+            y: position.y,
+            prevPropsPosition: {
+              ...position
+            }
+          };
+        }
+        return null;
+      }
+      constructor(props) {
+        super(props);
+        _defineProperty(this, "onDragStart", (e, coreData) => {
+          (0, _log.default)("Draggable: onDragStart: %j", coreData);
+          const shouldStart = this.props.onStart(e, (0, _positionFns.createDraggableData)(this, coreData));
+          if (shouldStart === false)
+            return false;
+          this.setState({
+            dragging: true,
+            dragged: true
+          });
+        });
+        _defineProperty(this, "onDrag", (e, coreData) => {
+          if (!this.state.dragging)
+            return false;
+          (0, _log.default)("Draggable: onDrag: %j", coreData);
+          const uiData = (0, _positionFns.createDraggableData)(this, coreData);
+          const newState = {
+            x: uiData.x,
+            y: uiData.y,
+            slackX: 0,
+            slackY: 0
+          };
+          if (this.props.bounds) {
+            const {
+              x,
+              y
+            } = newState;
+            newState.x += this.state.slackX;
+            newState.y += this.state.slackY;
+            const [newStateX, newStateY] = (0, _positionFns.getBoundPosition)(this, newState.x, newState.y);
+            newState.x = newStateX;
+            newState.y = newStateY;
+            newState.slackX = this.state.slackX + (x - newState.x);
+            newState.slackY = this.state.slackY + (y - newState.y);
+            uiData.x = newState.x;
+            uiData.y = newState.y;
+            uiData.deltaX = newState.x - this.state.x;
+            uiData.deltaY = newState.y - this.state.y;
+          }
+          const shouldUpdate = this.props.onDrag(e, uiData);
+          if (shouldUpdate === false)
+            return false;
+          this.setState(newState);
+        });
+        _defineProperty(this, "onDragStop", (e, coreData) => {
+          if (!this.state.dragging)
+            return false;
+          const shouldContinue = this.props.onStop(e, (0, _positionFns.createDraggableData)(this, coreData));
+          if (shouldContinue === false)
+            return false;
+          (0, _log.default)("Draggable: onDragStop: %j", coreData);
+          const newState = {
+            dragging: false,
+            slackX: 0,
+            slackY: 0
+          };
+          const controlled = Boolean(this.props.position);
+          if (controlled) {
+            const {
+              x,
+              y
+            } = this.props.position;
+            newState.x = x;
+            newState.y = y;
+          }
+          this.setState(newState);
+        });
+        this.state = {
+          // Whether or not we are currently dragging.
+          dragging: false,
+          // Whether or not we have been dragged before.
+          dragged: false,
+          // Current transform x and y.
+          x: props.position ? props.position.x : props.defaultPosition.x,
+          y: props.position ? props.position.y : props.defaultPosition.y,
+          prevPropsPosition: {
+            ...props.position
+          },
+          // Used for compensating for out-of-bounds drags
+          slackX: 0,
+          slackY: 0,
+          // Can only determine if SVG after mounting
+          isElementSVG: false
+        };
+        if (props.position && !(props.onDrag || props.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() {
+        if (typeof window.SVGElement !== "undefined" && this.findDOMNode() instanceof window.SVGElement) {
+          this.setState({
+            isElementSVG: true
+          });
+        }
+      }
+      componentWillUnmount() {
+        this.setState({
+          dragging: false
+        });
+      }
+      // 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 _this$props$nodeRef$c, _this$props;
+        return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 || (_this$props = _this$props.nodeRef) === null || _this$props === void 0 ? void 0 : _this$props.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom.default.findDOMNode(this);
+      }
+      render() {
+        const {
+          axis,
+          bounds,
+          children,
+          defaultPosition,
+          defaultClassName,
+          defaultClassNameDragging,
+          defaultClassNameDragged,
+          position,
+          positionOffset,
+          scale,
+          ...draggableCoreProps
+        } = this.props;
+        let style = {};
+        let svgTransform = null;
+        const controlled = Boolean(position);
+        const draggable = !controlled || this.state.dragging;
+        const validPosition = position || defaultPosition;
+        const transformOpts = {
+          // Set left if horizontal drag is enabled
+          x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : validPosition.x,
+          // Set top if vertical drag is enabled
+          y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : validPosition.y
+        };
+        if (this.state.isElementSVG) {
+          svgTransform = (0, _domFns.createSVGTransform)(transformOpts, positionOffset);
+        } else {
+          style = (0, _domFns.createCSSTransform)(transformOpts, positionOffset);
+        }
+        const className = (0, _clsx.default)(children.props.className || "", defaultClassName, {
+          [defaultClassNameDragging]: this.state.dragging,
+          [defaultClassNameDragged]: this.state.dragged
+        });
+        return /* @__PURE__ */ React.createElement(_DraggableCore.default, _extends({}, draggableCoreProps, {
+          onStart: this.onDragStart,
+          onDrag: this.onDrag,
+          onStop: this.onDragStop
+        }), /* @__PURE__ */ React.cloneElement(React.Children.only(children), {
+          className,
+          style: {
+            ...children.props.style,
+            ...style
+          },
+          transform: svgTransform
+        }));
+      }
+    };
+    exports.default = Draggable;
+    _defineProperty(Draggable, "displayName", "Draggable");
+    _defineProperty(Draggable, "propTypes", {
+      // Accepts all props <DraggableCore> accepts.
+      ..._DraggableCore.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: _propTypes.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: _propTypes.default.oneOfType([_propTypes.default.shape({
+        left: _propTypes.default.number,
+        right: _propTypes.default.number,
+        top: _propTypes.default.number,
+        bottom: _propTypes.default.number
+      }), _propTypes.default.string, _propTypes.default.oneOf([false])]),
+      defaultClassName: _propTypes.default.string,
+      defaultClassNameDragging: _propTypes.default.string,
+      defaultClassNameDragged: _propTypes.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: _propTypes.default.shape({
+        x: _propTypes.default.number,
+        y: _propTypes.default.number
+      }),
+      positionOffset: _propTypes.default.shape({
+        x: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
+        y: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.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: _propTypes.default.shape({
+        x: _propTypes.default.number,
+        y: _propTypes.default.number
+      }),
+      /**
+       * These properties should be defined on the child, not here.
+       */
+      className: _shims.dontSetMe,
+      style: _shims.dontSetMe,
+      transform: _shims.dontSetMe
+    });
+    _defineProperty(Draggable, "defaultProps", {
+      ..._DraggableCore.default.defaultProps,
+      axis: "both",
+      bounds: false,
+      defaultClassName: "react-draggable",
+      defaultClassNameDragging: "react-draggable-dragging",
+      defaultClassNameDragged: "react-draggable-dragged",
+      defaultPosition: {
+        x: 0,
+        y: 0
+      },
+      scale: 1
+    });
+  }
+});
+
+// node_modules/react-draggable/build/cjs/cjs.js
+var require_cjs = __commonJS({
+  "node_modules/react-draggable/build/cjs/cjs.js"(exports, module) {
+    "use strict";
+    var {
+      default: Draggable,
+      DraggableCore
+    } = require_Draggable();
+    module.exports = Draggable;
+    module.exports.default = Draggable;
+    module.exports.DraggableCore = DraggableCore;
+  }
+});
+
+// node_modules/react-resizable/build/utils.js
+var require_utils = __commonJS({
+  "node_modules/react-resizable/build/utils.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.cloneElement = cloneElement;
+    var _react = _interopRequireDefault(__require("react"));
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        enumerableOnly && (symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        })), keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = null != arguments[i] ? arguments[i] : {};
+        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+      return target;
+    }
+    function _defineProperty(obj, key, value) {
+      key = _toPropertyKey(key);
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return typeof key === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null)
+        return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (typeof res !== "object")
+          return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
+    function cloneElement(element, props) {
+      if (props.style && element.props.style) {
+        props.style = _objectSpread(_objectSpread({}, element.props.style), props.style);
+      }
+      if (props.className && element.props.className) {
+        props.className = element.props.className + " " + props.className;
+      }
+      return /* @__PURE__ */ _react.default.cloneElement(element, props);
+    }
+  }
+});
+
+// node_modules/react-resizable/build/propTypes.js
+var require_propTypes = __commonJS({
+  "node_modules/react-resizable/build/propTypes.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.resizableProps = void 0;
+    var _propTypes = _interopRequireDefault(require_prop_types());
+    var _reactDraggable = require_cjs();
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var resizableProps = {
+      /*
+      * Restricts resizing to a particular axis (default: 'both')
+      * 'both' - allows resizing by width or height
+      * 'x' - only allows the width to be changed
+      * 'y' - only allows the height to be changed
+      * 'none' - disables resizing altogether
+      * */
+      axis: _propTypes.default.oneOf(["both", "x", "y", "none"]),
+      className: _propTypes.default.string,
+      /*
+      * Require that one and only one child be present.
+      * */
+      children: _propTypes.default.element.isRequired,
+      /*
+      * These will be passed wholesale to react-draggable's DraggableCore
+      * */
+      draggableOpts: _propTypes.default.shape({
+        allowAnyClick: _propTypes.default.bool,
+        cancel: _propTypes.default.string,
+        children: _propTypes.default.node,
+        disabled: _propTypes.default.bool,
+        enableUserSelectHack: _propTypes.default.bool,
+        offsetParent: _propTypes.default.node,
+        grid: _propTypes.default.arrayOf(_propTypes.default.number),
+        handle: _propTypes.default.string,
+        nodeRef: _propTypes.default.object,
+        onStart: _propTypes.default.func,
+        onDrag: _propTypes.default.func,
+        onStop: _propTypes.default.func,
+        onMouseDown: _propTypes.default.func,
+        scale: _propTypes.default.number
+      }),
+      /*
+      * Initial height
+      * */
+      height: function height() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        var props = args[0];
+        if (props.axis === "both" || props.axis === "y") {
+          var _PropTypes$number;
+          return (_PropTypes$number = _propTypes.default.number).isRequired.apply(_PropTypes$number, args);
+        }
+        return _propTypes.default.number.apply(_propTypes.default, args);
+      },
+      /*
+      * Customize cursor resize handle
+      * */
+      handle: _propTypes.default.oneOfType([_propTypes.default.node, _propTypes.default.func]),
+      /*
+      * If you change this, be sure to update your css
+      * */
+      handleSize: _propTypes.default.arrayOf(_propTypes.default.number),
+      lockAspectRatio: _propTypes.default.bool,
+      /*
+      * Max X & Y measure
+      * */
+      maxConstraints: _propTypes.default.arrayOf(_propTypes.default.number),
+      /*
+      * Min X & Y measure
+      * */
+      minConstraints: _propTypes.default.arrayOf(_propTypes.default.number),
+      /*
+      * Called on stop resize event
+      * */
+      onResizeStop: _propTypes.default.func,
+      /*
+      * Called on start resize event
+      * */
+      onResizeStart: _propTypes.default.func,
+      /*
+      * Called on resize event
+      * */
+      onResize: _propTypes.default.func,
+      /*
+      * Defines which resize handles should be rendered (default: 'se')
+      * 's' - South handle (bottom-center)
+      * 'w' - West handle (left-center)
+      * 'e' - East handle (right-center)
+      * 'n' - North handle (top-center)
+      * 'sw' - Southwest handle (bottom-left)
+      * 'nw' - Northwest handle (top-left)
+      * 'se' - Southeast handle (bottom-right)
+      * 'ne' - Northeast handle (top-center)
+      * */
+      resizeHandles: _propTypes.default.arrayOf(_propTypes.default.oneOf(["s", "w", "e", "n", "sw", "nw", "se", "ne"])),
+      /*
+      * If `transform: scale(n)` is set on the parent, this should be set to `n`.
+      * */
+      transformScale: _propTypes.default.number,
+      /*
+       * Initial width
+       */
+      width: function width() {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        var props = args[0];
+        if (props.axis === "both" || props.axis === "x") {
+          var _PropTypes$number2;
+          return (_PropTypes$number2 = _propTypes.default.number).isRequired.apply(_PropTypes$number2, args);
+        }
+        return _propTypes.default.number.apply(_propTypes.default, args);
+      }
+    };
+    exports.resizableProps = resizableProps;
+  }
+});
+
+// node_modules/react-resizable/build/Resizable.js
+var require_Resizable = __commonJS({
+  "node_modules/react-resizable/build/Resizable.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.default = void 0;
+    var React = _interopRequireWildcard(__require("react"));
+    var _reactDraggable = require_cjs();
+    var _utils = require_utils();
+    var _propTypes = require_propTypes();
+    var _excluded = ["children", "className", "draggableOpts", "width", "height", "handle", "handleSize", "lockAspectRatio", "axis", "minConstraints", "maxConstraints", "onResize", "onResizeStop", "onResizeStart", "resizeHandles", "transformScale"];
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function")
+        return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function _getRequireWildcardCache2(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interopRequireWildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return { default: obj };
+      }
+      var cache = _getRequireWildcardCache(nodeInterop);
+      if (cache && cache.has(obj)) {
+        return cache.get(obj);
+      }
+      var newObj = {};
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj.default = obj;
+      if (cache) {
+        cache.set(obj, newObj);
+      }
+      return newObj;
+    }
+    function _extends() {
+      _extends = Object.assign ? Object.assign.bind() : function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    function _objectWithoutPropertiesLoose(source, excluded) {
+      if (source == null)
+        return {};
+      var target = {};
+      var sourceKeys = Object.keys(source);
+      var key, i;
+      for (i = 0; i < sourceKeys.length; i++) {
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0)
+          continue;
+        target[key] = source[key];
+      }
+      return target;
+    }
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        enumerableOnly && (symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        })), keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = null != arguments[i] ? arguments[i] : {};
+        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+      return target;
+    }
+    function _defineProperty(obj, key, value) {
+      key = _toPropertyKey(key);
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return typeof key === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null)
+        return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (typeof res !== "object")
+          return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
+    function _inheritsLoose(subClass, superClass) {
+      subClass.prototype = Object.create(superClass.prototype);
+      subClass.prototype.constructor = subClass;
+      _setPrototypeOf(subClass, superClass);
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      };
+      return _setPrototypeOf(o, p);
+    }
+    var Resizable2 = /* @__PURE__ */ function(_React$Component) {
+      _inheritsLoose(Resizable3, _React$Component);
+      function Resizable3() {
+        var _this;
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+        _this.handleRefs = {};
+        _this.lastHandleRect = null;
+        _this.slack = null;
+        return _this;
+      }
+      var _proto = Resizable3.prototype;
+      _proto.componentWillUnmount = function componentWillUnmount() {
+        this.resetData();
+      };
+      _proto.resetData = function resetData() {
+        this.lastHandleRect = this.slack = null;
+      };
+      _proto.runConstraints = function runConstraints(width, height) {
+        var _this$props = this.props, minConstraints = _this$props.minConstraints, maxConstraints = _this$props.maxConstraints, lockAspectRatio = _this$props.lockAspectRatio;
+        if (!minConstraints && !maxConstraints && !lockAspectRatio)
+          return [width, height];
+        if (lockAspectRatio) {
+          var ratio = this.props.width / this.props.height;
+          var deltaW = width - this.props.width;
+          var deltaH = height - this.props.height;
+          if (Math.abs(deltaW) > Math.abs(deltaH * ratio)) {
+            height = width / ratio;
+          } else {
+            width = height * ratio;
+          }
+        }
+        var oldW = width, oldH = height;
+        var _ref = this.slack || [0, 0], slackW = _ref[0], slackH = _ref[1];
+        width += slackW;
+        height += slackH;
+        if (minConstraints) {
+          width = Math.max(minConstraints[0], width);
+          height = Math.max(minConstraints[1], height);
+        }
+        if (maxConstraints) {
+          width = Math.min(maxConstraints[0], width);
+          height = Math.min(maxConstraints[1], height);
+        }
+        this.slack = [slackW + (oldW - width), slackH + (oldH - height)];
+        return [width, height];
+      };
+      _proto.resizeHandler = function resizeHandler(handlerName, axis) {
+        var _this2 = this;
+        return function(e, _ref2) {
+          var node = _ref2.node, deltaX = _ref2.deltaX, deltaY = _ref2.deltaY;
+          if (handlerName === "onResizeStart")
+            _this2.resetData();
+          var canDragX = (_this2.props.axis === "both" || _this2.props.axis === "x") && axis !== "n" && axis !== "s";
+          var canDragY = (_this2.props.axis === "both" || _this2.props.axis === "y") && axis !== "e" && axis !== "w";
+          if (!canDragX && !canDragY)
+            return;
+          var axisV = axis[0];
+          var axisH = axis[axis.length - 1];
+          var handleRect = node.getBoundingClientRect();
+          if (_this2.lastHandleRect != null) {
+            if (axisH === "w") {
+              var deltaLeftSinceLast = handleRect.left - _this2.lastHandleRect.left;
+              deltaX += deltaLeftSinceLast;
+            }
+            if (axisV === "n") {
+              var deltaTopSinceLast = handleRect.top - _this2.lastHandleRect.top;
+              deltaY += deltaTopSinceLast;
+            }
+          }
+          _this2.lastHandleRect = handleRect;
+          if (axisH === "w")
+            deltaX = -deltaX;
+          if (axisV === "n")
+            deltaY = -deltaY;
+          var width = _this2.props.width + (canDragX ? deltaX / _this2.props.transformScale : 0);
+          var height = _this2.props.height + (canDragY ? deltaY / _this2.props.transformScale : 0);
+          var _this2$runConstraints = _this2.runConstraints(width, height);
+          width = _this2$runConstraints[0];
+          height = _this2$runConstraints[1];
+          var dimensionsChanged = width !== _this2.props.width || height !== _this2.props.height;
+          var cb = typeof _this2.props[handlerName] === "function" ? _this2.props[handlerName] : null;
+          var shouldSkipCb = handlerName === "onResize" && !dimensionsChanged;
+          if (cb && !shouldSkipCb) {
+            e.persist == null ? void 0 : e.persist();
+            cb(e, {
+              node,
+              size: {
+                width,
+                height
+              },
+              handle: axis
+            });
+          }
+          if (handlerName === "onResizeStop")
+            _this2.resetData();
+        };
+      };
+      _proto.renderResizeHandle = function renderResizeHandle(handleAxis, ref) {
+        var handle = this.props.handle;
+        if (!handle) {
+          return /* @__PURE__ */ React.createElement("span", {
+            className: "react-resizable-handle react-resizable-handle-" + handleAxis,
+            ref
+          });
+        }
+        if (typeof handle === "function") {
+          return handle(handleAxis, ref);
+        }
+        var isDOMElement = typeof handle.type === "string";
+        var props = _objectSpread({
+          ref
+        }, isDOMElement ? {} : {
+          handleAxis
+        });
+        return /* @__PURE__ */ React.cloneElement(handle, props);
+      };
+      _proto.render = function render() {
+        var _this3 = this;
+        var _this$props2 = this.props, children = _this$props2.children, className = _this$props2.className, draggableOpts = _this$props2.draggableOpts, width = _this$props2.width, height = _this$props2.height, handle = _this$props2.handle, handleSize = _this$props2.handleSize, lockAspectRatio = _this$props2.lockAspectRatio, axis = _this$props2.axis, minConstraints = _this$props2.minConstraints, maxConstraints = _this$props2.maxConstraints, onResize = _this$props2.onResize, onResizeStop = _this$props2.onResizeStop, onResizeStart = _this$props2.onResizeStart, resizeHandles = _this$props2.resizeHandles, transformScale = _this$props2.transformScale, p = _objectWithoutPropertiesLoose(_this$props2, _excluded);
+        return (0, _utils.cloneElement)(children, _objectSpread(_objectSpread({}, p), {}, {
+          className: (className ? className + " " : "") + "react-resizable",
+          children: [].concat(children.props.children, resizeHandles.map(function(handleAxis) {
+            var _this3$handleRefs$han;
+            var ref = (_this3$handleRefs$han = _this3.handleRefs[handleAxis]) != null ? _this3$handleRefs$han : _this3.handleRefs[handleAxis] = /* @__PURE__ */ React.createRef();
+            return /* @__PURE__ */ React.createElement(_reactDraggable.DraggableCore, _extends({}, draggableOpts, {
+              nodeRef: ref,
+              key: "resizableHandle-" + handleAxis,
+              onStop: _this3.resizeHandler("onResizeStop", handleAxis),
+              onStart: _this3.resizeHandler("onResizeStart", handleAxis),
+              onDrag: _this3.resizeHandler("onResize", handleAxis)
+            }), _this3.renderResizeHandle(handleAxis, ref));
+          }))
+        }));
+      };
+      return Resizable3;
+    }(React.Component);
+    exports.default = Resizable2;
+    Resizable2.propTypes = _propTypes.resizableProps;
+    Resizable2.defaultProps = {
+      axis: "both",
+      handleSize: [20, 20],
+      lockAspectRatio: false,
+      minConstraints: [20, 20],
+      maxConstraints: [Infinity, Infinity],
+      resizeHandles: ["se"],
+      transformScale: 1
+    };
+  }
+});
+
+// node_modules/react-resizable/build/ResizableBox.js
+var require_ResizableBox = __commonJS({
+  "node_modules/react-resizable/build/ResizableBox.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.default = void 0;
+    var React = _interopRequireWildcard(__require("react"));
+    var _propTypes = _interopRequireDefault(require_prop_types());
+    var _Resizable = _interopRequireDefault(require_Resizable());
+    var _propTypes2 = require_propTypes();
+    var _excluded = ["handle", "handleSize", "onResize", "onResizeStart", "onResizeStop", "draggableOpts", "minConstraints", "maxConstraints", "lockAspectRatio", "axis", "width", "height", "resizeHandles", "style", "transformScale"];
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function")
+        return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function _getRequireWildcardCache2(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interopRequireWildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return { default: obj };
+      }
+      var cache = _getRequireWildcardCache(nodeInterop);
+      if (cache && cache.has(obj)) {
+        return cache.get(obj);
+      }
+      var newObj = {};
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj.default = obj;
+      if (cache) {
+        cache.set(obj, newObj);
+      }
+      return newObj;
+    }
+    function _extends() {
+      _extends = Object.assign ? Object.assign.bind() : function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        enumerableOnly && (symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        })), keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = null != arguments[i] ? arguments[i] : {};
+        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+      return target;
+    }
+    function _defineProperty(obj, key, value) {
+      key = _toPropertyKey(key);
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return typeof key === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (typeof input !== "object" || input === null)
+        return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (typeof res !== "object")
+          return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
+    function _objectWithoutPropertiesLoose(source, excluded) {
+      if (source == null)
+        return {};
+      var target = {};
+      var sourceKeys = Object.keys(source);
+      var key, i;
+      for (i = 0; i < sourceKeys.length; i++) {
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0)
+          continue;
+        target[key] = source[key];
+      }
+      return target;
+    }
+    function _inheritsLoose(subClass, superClass) {
+      subClass.prototype = Object.create(superClass.prototype);
+      subClass.prototype.constructor = subClass;
+      _setPrototypeOf(subClass, superClass);
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      };
+      return _setPrototypeOf(o, p);
+    }
+    var ResizableBox = /* @__PURE__ */ function(_React$Component) {
+      _inheritsLoose(ResizableBox2, _React$Component);
+      function ResizableBox2() {
+        var _this;
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+        _this.state = {
+          width: _this.props.width,
+          height: _this.props.height,
+          propsWidth: _this.props.width,
+          propsHeight: _this.props.height
+        };
+        _this.onResize = function(e, data) {
+          var size = data.size;
+          if (_this.props.onResize) {
+            e.persist == null ? void 0 : e.persist();
+            _this.setState(size, function() {
+              return _this.props.onResize && _this.props.onResize(e, data);
+            });
+          } else {
+            _this.setState(size);
+          }
+        };
+        return _this;
+      }
+      ResizableBox2.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {
+        if (state.propsWidth !== props.width || state.propsHeight !== props.height) {
+          return {
+            width: props.width,
+            height: props.height,
+            propsWidth: props.width,
+            propsHeight: props.height
+          };
+        }
+        return null;
+      };
+      var _proto = ResizableBox2.prototype;
+      _proto.render = function render() {
+        var _this$props = this.props, handle = _this$props.handle, handleSize = _this$props.handleSize, onResize = _this$props.onResize, onResizeStart = _this$props.onResizeStart, onResizeStop = _this$props.onResizeStop, draggableOpts = _this$props.draggableOpts, minConstraints = _this$props.minConstraints, maxConstraints = _this$props.maxConstraints, lockAspectRatio = _this$props.lockAspectRatio, axis = _this$props.axis, width = _this$props.width, height = _this$props.height, resizeHandles = _this$props.resizeHandles, style = _this$props.style, transformScale = _this$props.transformScale, props = _objectWithoutPropertiesLoose(_this$props, _excluded);
+        return /* @__PURE__ */ React.createElement(_Resizable.default, {
+          axis,
+          draggableOpts,
+          handle,
+          handleSize,
+          height: this.state.height,
+          lockAspectRatio,
+          maxConstraints,
+          minConstraints,
+          onResizeStart,
+          onResize: this.onResize,
+          onResizeStop,
+          resizeHandles,
+          transformScale,
+          width: this.state.width
+        }, /* @__PURE__ */ React.createElement("div", _extends({}, props, {
+          style: _objectSpread(_objectSpread({}, style), {}, {
+            width: this.state.width + "px",
+            height: this.state.height + "px"
+          })
+        })));
+      };
+      return ResizableBox2;
+    }(React.Component);
+    exports.default = ResizableBox;
+    ResizableBox.propTypes = _objectSpread(_objectSpread({}, _propTypes2.resizableProps), {}, {
+      children: _propTypes.default.element
+    });
+  }
+});
+
+// node_modules/react-resizable/index.js
+var require_react_resizable = __commonJS({
+  "node_modules/react-resizable/index.js"(exports, module) {
+    "use strict";
+    module.exports = function() {
+      throw new Error("Don't instantiate Resizable directly! Use require('react-resizable').Resizable");
+    };
+    module.exports.Resizable = require_Resizable().default;
+    module.exports.ResizableBox = require_ResizableBox().default;
+  }
+});
+
 // test-app/src/component/table/index.tsx
 import { Fragment as Fragment17, forwardRef as forwardRef3, useEffect as useEffect8, useImperativeHandle, useRef as useRef3, useState as useState7 } from "react";
 import { Button as Button5, DropdownMenu as DropdownMenu3, DropdownToggle as DropdownToggle3, Input as Input8, UncontrolledDropdown, UncontrolledTooltip as UncontrolledTooltip3 } from "reactstrap";
@@ -216,15 +3250,15 @@ var generateUUID = () => {
   let d = (/* @__PURE__ */ new Date()).getTime();
   let d2 = typeof performance !== "undefined" && performance.now && performance.now() * 1e3 || 0;
   return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-    let r = Math.random() * 16;
+    let r2 = Math.random() * 16;
     if (d > 0) {
-      r = (d + r) % 16 | 0;
+      r2 = (d + r2) % 16 | 0;
       d = Math.floor(d / 16);
     } else {
-      r = (d2 + r) % 16 | 0;
+      r2 = (d2 + r2) % 16 | 0;
       d2 = Math.floor(d2 / 16);
     }
-    return (c === "x" ? r : 3).toString(16);
+    return (c === "x" ? r2 : 3).toString(16);
   });
 };
 var objSymbolDecimal = { 0: ",", 1: "." };
@@ -2112,6 +5146,7 @@ var SelectTable = forwardRef2((props, ref) => {
 });
 
 // test-app/src/component/table/header.tsx
+var import_react_resizable = __toESM(require_react_resizable());
 import { Fragment as Fragment14 } from "react";
 import classnames7 from "classnames";
 import { Input as Input7 } from "reactstrap";
@@ -2128,51 +5163,70 @@ var HeaderTableCol = (props) => {
     objWidthFix,
     totalCount,
     selectedRows,
+    column,
+    setColumn,
     isMulti
   } = props;
   const { t } = useTranslation10();
+  const handleResize = (e, { size }) => {
+    if (size.width > 50) {
+      const newColumns = [...column];
+      newColumns[indexCol].width = size.width;
+      setColumn(newColumns);
+    }
+  };
   return /* @__PURE__ */ jsx13(Fragment14, { children: col.visible !== false && /* @__PURE__ */ jsx13(
-    "th",
+    import_react_resizable.Resizable,
     {
-      rowSpan: col.rowspan !== 1 ? col.rowspan : void 0,
-      colSpan: col.columns?.length ?? 1,
-      className: classnames7(`r-headercell fix-${col.fixedType}`, { "cell-fixed": col.fixedType }),
-      style: {
-        top: `${indexParent * 42}px`,
-        left: col.fixedType === "left" ? objWidthFix[col.index ?? 0] : void 0,
-        right: col.fixedType === "right" ? objWidthFix[col.index ?? 0] : void 0,
-        width: col.fixedType ? Number(col.maxWidth ? col.maxWidth : col.width ? col.width : col.minWidth ?? "auto") : col.width,
-        minWidth: col.fixedType ? Number(col.maxWidth ? col.maxWidth : col.width ? col.width : col.minWidth ?? "auto") : col.minWidth,
-        maxWidth: col.fixedType ? Number(col.maxWidth ? col.maxWidth : col.width ? col.width : col.minWidth ?? "auto") : col.width
-      },
-      children: /* @__PURE__ */ jsxs13(
-        "div",
+      className: "r-resize",
+      width: Number(col.width ?? 0),
+      height: 0,
+      onResize: handleResize,
+      draggableOpts: { enableUserSelectHack: false },
+      children: /* @__PURE__ */ jsx13(
+        "th",
         {
-          style: { justifyContent: col.textAlign ?? "left" },
-          className: classnames7("r-headercell-div"),
-          children: [
-            col.field === "checkbox" && /* @__PURE__ */ jsx13(
-              Input7,
-              {
-                checked: totalCount > 0 && selectedRows?.length >= totalCount,
-                type: "checkbox",
-                className: classnames7("cursor-pointer", { "d-none": !isMulti }),
-                style: { textAlign: col.textAlign ?? "left", marginTop: 6 },
-                onChange: (e) => {
-                  if (selectEnable) {
-                    if (e.target.checked) {
-                      setSelectedRows(dataSource.map((item) => {
-                        return item;
-                      }));
-                    } else {
-                      setSelectedRows([]);
+          rowSpan: col.rowspan !== 1 ? col.rowspan : void 0,
+          colSpan: col.columns?.length ?? 1,
+          className: classnames7(`r-headercell fix-${col.fixedType}`, { "cell-fixed": col.fixedType }),
+          style: {
+            top: `${indexParent * 42}px`,
+            left: col.fixedType === "left" ? objWidthFix[col.index ?? 0] : void 0,
+            right: col.fixedType === "right" ? objWidthFix[col.index ?? 0] : void 0,
+            width: col.width,
+            minWidth: col.width,
+            maxWidth: col.width
+          },
+          children: /* @__PURE__ */ jsxs13(
+            "div",
+            {
+              style: { justifyContent: col.textAlign ?? "left" },
+              className: classnames7("r-headercell-div"),
+              children: [
+                col.field === "checkbox" && /* @__PURE__ */ jsx13(
+                  Input7,
+                  {
+                    checked: totalCount > 0 && selectedRows?.length >= totalCount,
+                    type: "checkbox",
+                    className: classnames7("cursor-pointer", { "d-none": !isMulti }),
+                    style: { textAlign: col.textAlign ?? "left", marginTop: 6 },
+                    onChange: (e) => {
+                      if (selectEnable) {
+                        if (e.target.checked) {
+                          setSelectedRows(dataSource.map((item) => {
+                            return item;
+                          }));
+                        } else {
+                          setSelectedRows([]);
+                        }
+                      }
                     }
                   }
-                }
-              }
-            ),
-            col.field !== "checkbox" && t(col.headerText ?? "")
-          ]
+                ),
+                col.field !== "checkbox" && t(col.headerText ?? "")
+              ]
+            }
+          )
         }
       )
     }
@@ -2302,17 +5356,18 @@ var TableEdit = forwardRef3((props, ref) => {
     let rightWidthFix = 0;
     contentColumns.forEach((item, index) => {
       if (levelCol === 1) {
+        headerColumns[0][index].width = item.width;
         headerColumns[0][index].visible = item.visible;
         headerColumns[0][index].fixedType = item.fixedType;
       }
       if (item.fixedType === "left" && item.visible !== false) {
         objWidthFix[index] = letfWidthFix;
-        letfWidthFix += Number(item.maxWidth ? item.maxWidth : item.width ? item.width : item.minWidth ?? 40);
+        letfWidthFix += Number(item.width ?? 40);
       }
       const lasColumn = contentColumns[contentColumns.length - 1 - index];
       if (lasColumn.fixedType === "right" && lasColumn.visible !== false) {
         objWidthFix[contentColumns.length - 1 - index] = rightWidthFix;
-        rightWidthFix += Number(lasColumn.maxWidth ? lasColumn.maxWidth : lasColumn.width ? lasColumn.width : lasColumn.minWidth ?? 40);
+        rightWidthFix += Number(lasColumn.width ?? 40);
       }
       if (item.editEnable && item.visible !== false && !item.disabledCondition) {
         if (indexFirst === -1) {
@@ -3433,9 +6488,6 @@ var TableEdit = forwardRef3((props, ref) => {
             "div",
             {
               className: classnames9("r-rowcell-div"),
-              style: {
-                width: col.fixedType ? Number(col.maxWidth ? col.maxWidth : col.width ? col.width : col.minWidth ?? "auto") : col.width
-              },
               children: /* @__PURE__ */ jsxs15(
                 "div",
                 {
@@ -3482,9 +6534,7 @@ var TableEdit = forwardRef3((props, ref) => {
         style: {
           left: col.fixedType === "left" ? objWidthFix[indexCol] : void 0,
           right: col.fixedType === "right" ? objWidthFix[indexCol] : void 0,
-          width: col.fixedType ? Number(col.maxWidth ? col.maxWidth : col.width ? col.width : col.minWidth ?? "auto") : col.width,
-          minWidth: col.fixedType ? Number(col.maxWidth ? col.maxWidth : col.width ? col.width : col.minWidth ?? "auto") : col.minWidth,
-          maxWidth: col.maxWidth,
+          width: col.width,
           textAlign: col.textAlign ? col.textAlign : "left"
         },
         children: /* @__PURE__ */ jsx16("div", { className: "r-footer-div", children: col.haveSum === true && col.editType === "numeric" ? formartNumberic(dataSource.reduce(function(accumulator, currentValue) {
@@ -3603,6 +6653,8 @@ var TableEdit = forwardRef3((props, ref) => {
                   selectEnable: selectEnable ?? false,
                   selectedRows,
                   setSelectedRows,
+                  column: contentColumns,
+                  setColumn: setContentColumns,
                   totalCount
                 },
                 `header-${indexParent}-${index}`
@@ -4644,13 +7696,24 @@ var OptionFont = [
 // test-app/src/component/input-style/index.tsx
 import { jsx as jsx18, jsxs as jsxs17 } from "react/jsx-runtime";
 var InputStyleComponent = (props) => {
-  const { value, onChange, disabled } = props;
+  const {
+    value,
+    onChange,
+    disabled,
+    disabledColor,
+    disabledBackgroundColor,
+    disabledFontFamily,
+    disabledFontSize,
+    disabledBold,
+    disabledItalic,
+    disabledUnderline
+  } = props;
   return /* @__PURE__ */ jsx18(Fragment20, { children: /* @__PURE__ */ jsxs17("div", { className: "d-flex align-items-center", children: [
     /* @__PURE__ */ jsx18(
       SelectTable,
       {
         options: OptionFont,
-        isDisabled: disabled,
+        isDisabled: disabled || disabledFontFamily,
         noHeader: true,
         value: value.fontFamily ? OptionFont.find((x) => x.label === value.fontFamily) : null,
         onChange: (val) => {
@@ -4680,7 +7743,7 @@ var InputStyleComponent = (props) => {
         }
       }
     ),
-    /* @__PURE__ */ jsx18("div", { className: "ms-25", style: { width: 60 }, children: /* @__PURE__ */ jsx18(
+    /* @__PURE__ */ jsx18("div", { className: classnames10("ms-25", { "d-none": disabledFontSize }), style: { width: 60 }, children: /* @__PURE__ */ jsx18(
       SelectTable,
       {
         options: Array.from({ length: 100 }, (_, i) => ({ value: i + 1, label: i + 1 })),
@@ -4695,7 +7758,7 @@ var InputStyleComponent = (props) => {
     /* @__PURE__ */ jsx18(
       "div",
       {
-        className: classnames10("btn-input-style", { "active-custom": value.bold }),
+        className: classnames10("btn-input-style", { "active-custom": value.bold }, { "d-none": disabledBold }),
         onClick: () => {
           if (!disabled) {
             onChange({ ...value, bold: !value.bold });
@@ -4707,7 +7770,7 @@ var InputStyleComponent = (props) => {
     /* @__PURE__ */ jsx18(
       "div",
       {
-        className: classnames10("btn-input-style", { "active-custom": value.italic }),
+        className: classnames10("btn-input-style", { "active-custom": value.italic }, { "d-none": disabledItalic }),
         onClick: () => {
           if (!disabled) {
             onChange({ ...value, italic: !value.italic });
@@ -4719,7 +7782,7 @@ var InputStyleComponent = (props) => {
     /* @__PURE__ */ jsx18(
       "div",
       {
-        className: classnames10("btn-input-style", { "active-custom": value.underline }),
+        className: classnames10("btn-input-style", { "active-custom": value.underline }, { "d-none": disabledUnderline }),
         onClick: () => {
           if (!disabled) {
             onChange({ ...value, underline: !value.underline });
@@ -4728,7 +7791,7 @@ var InputStyleComponent = (props) => {
         children: /* @__PURE__ */ jsx18(Underline, { fontSize: 18 })
       }
     ),
-    /* @__PURE__ */ jsxs17(Button6, { tag: "label", color: "none", className: "btn-input-style", children: [
+    /* @__PURE__ */ jsxs17(Button6, { tag: "label", color: "none", className: classnames10("btn-input-style", { "d-none": disabledColor }), children: [
       /* @__PURE__ */ jsx18(Type, { stroke: value.color ?? "#000000", fontSize: 18 }),
       /* @__PURE__ */ jsx18(
         "input",
@@ -4744,7 +7807,7 @@ var InputStyleComponent = (props) => {
         }
       )
     ] }),
-    /* @__PURE__ */ jsxs17(Button6, { tag: "label", color: "none", className: "btn-input-style", children: [
+    /* @__PURE__ */ jsxs17(Button6, { tag: "label", color: "none", className: classnames10("btn-input-style", { "d-none": disabledBackgroundColor }), children: [
       /* @__PURE__ */ jsx18(Droplet, { fill: value.backgroundColor ?? "#ffffff", fontSize: 18 }),
       /* @__PURE__ */ jsx18(
         Input9,
@@ -4786,3 +7849,32 @@ export {
   roundNumber,
   useOnClickOutside
 };
+/*! Bundled license information:
+
+react-is/cjs/react-is.production.min.js:
+  (** @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.
+   *)
+
+react-is/cjs/react-is.development.js:
+  (** @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.
+   *)
+
+object-assign/index.js:
+  (*
+  object-assign
+  (c) Sindre Sorhus
+  @license MIT
+  *)
+*/