react-timelane 1.2.1 → 1.2.2

package/dist/node_modules/re-resizable/lib/index.js

@@ -0,0 +1,424 @@
+import { jsx as A, jsxs as V } from "react/jsx-runtime";
+import { PureComponent as Z } from "react";
+import { r as q } from "../../../_virtual/index3.js";
+import { Resizer as J } from "./resizer.js";
+var K = /* @__PURE__ */ function() {
+  var r = function(o, t) {
+    return r = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(e, i) {
+      e.__proto__ = i;
+    } || function(e, i) {
+      for (var n in i) Object.prototype.hasOwnProperty.call(i, n) && (e[n] = i[n]);
+    }, r(o, t);
+  };
+  return function(o, t) {
+    if (typeof t != "function" && t !== null)
+      throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+    r(o, t);
+    function e() {
+      this.constructor = o;
+    }
+    o.prototype = t === null ? Object.create(t) : (e.prototype = t.prototype, new e());
+  };
+}(), z = function() {
+  return z = Object.assign || function(r) {
+    for (var o, t = 1, e = arguments.length; t < e; t++) {
+      o = arguments[t];
+      for (var i in o) Object.prototype.hasOwnProperty.call(o, i) && (r[i] = o[i]);
+    }
+    return r;
+  }, z.apply(this, arguments);
+}, Q = {
+  width: "auto",
+  height: "auto"
+}, B = function(r, o, t) {
+  return Math.max(Math.min(r, t), o);
+}, O = function(r, o, t) {
+  var e = Math.round(r / o);
+  return e * o + t * (e - 1);
+}, x = function(r, o) {
+  return new RegExp(r, "i").test(o);
+}, _ = function(r) {
+  return !!(r.touches && r.touches.length);
+}, $ = function(r) {
+  return !!((r.clientX || r.clientX === 0) && (r.clientY || r.clientY === 0));
+}, j = function(r, o, t) {
+  t === void 0 && (t = 0);
+  var e = o.reduce(function(n, a, s) {
+    return Math.abs(a - r) < Math.abs(o[n] - r) ? s : n;
+  }, 0), i = Math.abs(o[e] - r);
+  return t === 0 || i < t ? o[e] : r;
+}, P = function(r) {
+  return r = r.toString(), r === "auto" || r.endsWith("px") || r.endsWith("%") || r.endsWith("vh") || r.endsWith("vw") || r.endsWith("vmax") || r.endsWith("vmin") ? r : "".concat(r, "px");
+}, N = function(r, o, t, e) {
+  if (r && typeof r == "string") {
+    if (r.endsWith("px"))
+      return Number(r.replace("px", ""));
+    if (r.endsWith("%")) {
+      var i = Number(r.replace("%", "")) / 100;
+      return o * i;
+    }
+    if (r.endsWith("vw")) {
+      var i = Number(r.replace("vw", "")) / 100;
+      return t * i;
+    }
+    if (r.endsWith("vh")) {
+      var i = Number(r.replace("vh", "")) / 100;
+      return e * i;
+    }
+  }
+  return r;
+}, tt = function(r, o, t, e, i, n, a) {
+  return e = N(e, r.width, o, t), i = N(i, r.height, o, t), n = N(n, r.width, o, t), a = N(a, r.height, o, t), {
+    maxWidth: typeof e > "u" ? void 0 : Number(e),
+    maxHeight: typeof i > "u" ? void 0 : Number(i),
+    minWidth: typeof n > "u" ? void 0 : Number(n),
+    minHeight: typeof a > "u" ? void 0 : Number(a)
+  };
+}, et = function(r) {
+  return Array.isArray(r) ? r : [r, r];
+}, it = [
+  "as",
+  "ref",
+  "style",
+  "className",
+  "grid",
+  "gridGap",
+  "snap",
+  "bounds",
+  "boundsByDirection",
+  "size",
+  "defaultSize",
+  "minWidth",
+  "minHeight",
+  "maxWidth",
+  "maxHeight",
+  "lockAspectRatio",
+  "lockAspectRatioExtraWidth",
+  "lockAspectRatioExtraHeight",
+  "enable",
+  "handleStyles",
+  "handleClasses",
+  "handleWrapperStyle",
+  "handleWrapperClass",
+  "children",
+  "onResizeStart",
+  "onResize",
+  "onResizeStop",
+  "handleComponent",
+  "scale",
+  "resizeRatio",
+  "snapGap"
+], F = "__resizable_base__", ht = (
+  /** @class */
+  function(r) {
+    K(o, r);
+    function o(t) {
+      var e, i, n, a, s = r.call(this, t) || this;
+      return s.ratio = 1, s.resizable = null, s.parentLeft = 0, s.parentTop = 0, s.resizableLeft = 0, s.resizableRight = 0, s.resizableTop = 0, s.resizableBottom = 0, s.targetLeft = 0, s.targetTop = 0, s.delta = {
+        width: 0,
+        height: 0
+      }, s.appendBase = function() {
+        if (!s.resizable || !s.window)
+          return null;
+        var p = s.parentNode;
+        if (!p)
+          return null;
+        var h = s.window.document.createElement("div");
+        return h.style.width = "100%", h.style.height = "100%", h.style.position = "absolute", h.style.transform = "scale(0, 0)", h.style.left = "0", h.style.flex = "0 0 100%", h.classList ? h.classList.add(F) : h.className += F, p.appendChild(h), h;
+      }, s.removeBase = function(p) {
+        var h = s.parentNode;
+        h && h.removeChild(p);
+      }, s.state = {
+        isResizing: !1,
+        width: (i = (e = s.propsSize) === null || e === void 0 ? void 0 : e.width) !== null && i !== void 0 ? i : "auto",
+        height: (a = (n = s.propsSize) === null || n === void 0 ? void 0 : n.height) !== null && a !== void 0 ? a : "auto",
+        direction: "right",
+        original: {
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0
+        },
+        backgroundStyle: {
+          height: "100%",
+          width: "100%",
+          backgroundColor: "rgba(0,0,0,0)",
+          cursor: "auto",
+          opacity: 0,
+          position: "fixed",
+          zIndex: 9999,
+          top: "0",
+          left: "0",
+          bottom: "0",
+          right: "0"
+        },
+        flexBasis: void 0
+      }, s.onResizeStart = s.onResizeStart.bind(s), s.onMouseMove = s.onMouseMove.bind(s), s.onMouseUp = s.onMouseUp.bind(s), s;
+    }
+    return Object.defineProperty(o.prototype, "parentNode", {
+      get: function() {
+        return this.resizable ? this.resizable.parentNode : null;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(o.prototype, "window", {
+      get: function() {
+        return !this.resizable || !this.resizable.ownerDocument ? null : this.resizable.ownerDocument.defaultView;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(o.prototype, "propsSize", {
+      get: function() {
+        return this.props.size || this.props.defaultSize || Q;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(o.prototype, "size", {
+      get: function() {
+        var t = 0, e = 0;
+        if (this.resizable && this.window) {
+          var i = this.resizable.offsetWidth, n = this.resizable.offsetHeight, a = this.resizable.style.position;
+          a !== "relative" && (this.resizable.style.position = "relative"), t = this.resizable.style.width !== "auto" ? this.resizable.offsetWidth : i, e = this.resizable.style.height !== "auto" ? this.resizable.offsetHeight : n, this.resizable.style.position = a;
+        }
+        return { width: t, height: e };
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(o.prototype, "sizeStyle", {
+      get: function() {
+        var t = this, e = this.props.size, i = function(s) {
+          var p;
+          if (typeof t.state[s] > "u" || t.state[s] === "auto")
+            return "auto";
+          if (t.propsSize && t.propsSize[s] && (!((p = t.propsSize[s]) === null || p === void 0) && p.toString().endsWith("%"))) {
+            if (t.state[s].toString().endsWith("%"))
+              return t.state[s].toString();
+            var h = t.getParentSize(), l = Number(t.state[s].toString().replace("px", "")), d = l / h[s] * 100;
+            return "".concat(d, "%");
+          }
+          return P(t.state[s]);
+        }, n = e && typeof e.width < "u" && !this.state.isResizing ? P(e.width) : i("width"), a = e && typeof e.height < "u" && !this.state.isResizing ? P(e.height) : i("height");
+        return { width: n, height: a };
+      },
+      enumerable: !1,
+      configurable: !0
+    }), o.prototype.getParentSize = function() {
+      if (!this.parentNode)
+        return this.window ? { width: this.window.innerWidth, height: this.window.innerHeight } : { width: 0, height: 0 };
+      var t = this.appendBase();
+      if (!t)
+        return { width: 0, height: 0 };
+      var e = !1, i = this.parentNode.style.flexWrap;
+      i !== "wrap" && (e = !0, this.parentNode.style.flexWrap = "wrap"), t.style.position = "relative", t.style.minWidth = "100%", t.style.minHeight = "100%";
+      var n = {
+        width: t.offsetWidth,
+        height: t.offsetHeight
+      };
+      return e && (this.parentNode.style.flexWrap = i), this.removeBase(t), n;
+    }, o.prototype.bindEvents = function() {
+      this.window && (this.window.addEventListener("mouseup", this.onMouseUp), this.window.addEventListener("mousemove", this.onMouseMove), this.window.addEventListener("mouseleave", this.onMouseUp), this.window.addEventListener("touchmove", this.onMouseMove, {
+        capture: !0,
+        passive: !1
+      }), this.window.addEventListener("touchend", this.onMouseUp));
+    }, o.prototype.unbindEvents = function() {
+      this.window && (this.window.removeEventListener("mouseup", this.onMouseUp), this.window.removeEventListener("mousemove", this.onMouseMove), this.window.removeEventListener("mouseleave", this.onMouseUp), this.window.removeEventListener("touchmove", this.onMouseMove, !0), this.window.removeEventListener("touchend", this.onMouseUp));
+    }, o.prototype.componentDidMount = function() {
+      if (!(!this.resizable || !this.window)) {
+        var t = this.window.getComputedStyle(this.resizable);
+        this.setState({
+          width: this.state.width || this.size.width,
+          height: this.state.height || this.size.height,
+          flexBasis: t.flexBasis !== "auto" ? t.flexBasis : void 0
+        });
+      }
+    }, o.prototype.componentWillUnmount = function() {
+      this.window && this.unbindEvents();
+    }, o.prototype.createSizeForCssProperty = function(t, e) {
+      var i = this.propsSize && this.propsSize[e];
+      return this.state[e] === "auto" && this.state.original[e] === t && (typeof i > "u" || i === "auto") ? "auto" : t;
+    }, o.prototype.calculateNewMaxFromBoundary = function(t, e) {
+      var i = this.props.boundsByDirection, n = this.state.direction, a = i && x("left", n), s = i && x("top", n), p, h;
+      if (this.props.bounds === "parent") {
+        var l = this.parentNode;
+        l && (p = a ? this.resizableRight - this.parentLeft : l.offsetWidth + (this.parentLeft - this.resizableLeft), h = s ? this.resizableBottom - this.parentTop : l.offsetHeight + (this.parentTop - this.resizableTop));
+      } else this.props.bounds === "window" ? this.window && (p = a ? this.resizableRight : this.window.innerWidth - this.resizableLeft, h = s ? this.resizableBottom : this.window.innerHeight - this.resizableTop) : this.props.bounds && (p = a ? this.resizableRight - this.targetLeft : this.props.bounds.offsetWidth + (this.targetLeft - this.resizableLeft), h = s ? this.resizableBottom - this.targetTop : this.props.bounds.offsetHeight + (this.targetTop - this.resizableTop));
+      return p && Number.isFinite(p) && (t = t && t < p ? t : p), h && Number.isFinite(h) && (e = e && e < h ? e : h), { maxWidth: t, maxHeight: e };
+    }, o.prototype.calculateNewSizeFromDirection = function(t, e) {
+      var i = this.props.scale || 1, n = et(this.props.resizeRatio || 1), a = n[0], s = n[1], p = this.state, h = p.direction, l = p.original, d = this.props, b = d.lockAspectRatio, y = d.lockAspectRatioExtraHeight, g = d.lockAspectRatioExtraWidth, u = l.width, v = l.height, w = y || 0, m = g || 0;
+      return x("right", h) && (u = l.width + (t - l.x) * a / i, b && (v = (u - m) / this.ratio + w)), x("left", h) && (u = l.width - (t - l.x) * a / i, b && (v = (u - m) / this.ratio + w)), x("bottom", h) && (v = l.height + (e - l.y) * s / i, b && (u = (v - w) * this.ratio + m)), x("top", h) && (v = l.height - (e - l.y) * s / i, b && (u = (v - w) * this.ratio + m)), { newWidth: u, newHeight: v };
+    }, o.prototype.calculateNewSizeFromAspectRatio = function(t, e, i, n) {
+      var a = this.props, s = a.lockAspectRatio, p = a.lockAspectRatioExtraHeight, h = a.lockAspectRatioExtraWidth, l = typeof n.width > "u" ? 10 : n.width, d = typeof i.width > "u" || i.width < 0 ? t : i.width, b = typeof n.height > "u" ? 10 : n.height, y = typeof i.height > "u" || i.height < 0 ? e : i.height, g = p || 0, u = h || 0;
+      if (s) {
+        var v = (b - g) * this.ratio + u, w = (y - g) * this.ratio + u, m = (l - u) / this.ratio + g, f = (d - u) / this.ratio + g, c = Math.max(l, v), R = Math.min(d, w), W = Math.max(b, m), M = Math.min(y, f);
+        t = B(t, c, R), e = B(e, W, M);
+      } else
+        t = B(t, l, d), e = B(e, b, y);
+      return { newWidth: t, newHeight: e };
+    }, o.prototype.setBoundingClientRect = function() {
+      var t = 1 / (this.props.scale || 1);
+      if (this.props.bounds === "parent") {
+        var e = this.parentNode;
+        if (e) {
+          var i = e.getBoundingClientRect();
+          this.parentLeft = i.left * t, this.parentTop = i.top * t;
+        }
+      }
+      if (this.props.bounds && typeof this.props.bounds != "string") {
+        var n = this.props.bounds.getBoundingClientRect();
+        this.targetLeft = n.left * t, this.targetTop = n.top * t;
+      }
+      if (this.resizable) {
+        var a = this.resizable.getBoundingClientRect(), s = a.left, p = a.top, h = a.right, l = a.bottom;
+        this.resizableLeft = s * t, this.resizableRight = h * t, this.resizableTop = p * t, this.resizableBottom = l * t;
+      }
+    }, o.prototype.onResizeStart = function(t, e) {
+      if (!(!this.resizable || !this.window)) {
+        var i = 0, n = 0;
+        if (t.nativeEvent && $(t.nativeEvent) ? (i = t.nativeEvent.clientX, n = t.nativeEvent.clientY) : t.nativeEvent && _(t.nativeEvent) && (i = t.nativeEvent.touches[0].clientX, n = t.nativeEvent.touches[0].clientY), this.props.onResizeStart && this.resizable) {
+          var a = this.props.onResizeStart(t, e, this.resizable);
+          if (a === !1)
+            return;
+        }
+        this.props.size && (typeof this.props.size.height < "u" && this.props.size.height !== this.state.height && this.setState({ height: this.props.size.height }), typeof this.props.size.width < "u" && this.props.size.width !== this.state.width && this.setState({ width: this.props.size.width })), this.ratio = typeof this.props.lockAspectRatio == "number" ? this.props.lockAspectRatio : this.size.width / this.size.height;
+        var s, p = this.window.getComputedStyle(this.resizable);
+        if (p.flexBasis !== "auto") {
+          var h = this.parentNode;
+          if (h) {
+            var l = this.window.getComputedStyle(h).flexDirection;
+            this.flexDir = l.startsWith("row") ? "row" : "column", s = p.flexBasis;
+          }
+        }
+        this.setBoundingClientRect(), this.bindEvents();
+        var d = {
+          original: {
+            x: i,
+            y: n,
+            width: this.size.width,
+            height: this.size.height
+          },
+          isResizing: !0,
+          backgroundStyle: z(z({}, this.state.backgroundStyle), { cursor: this.window.getComputedStyle(t.target).cursor || "auto" }),
+          direction: e,
+          flexBasis: s
+        };
+        this.setState(d);
+      }
+    }, o.prototype.onMouseMove = function(t) {
+      var e = this;
+      if (!(!this.state.isResizing || !this.resizable || !this.window)) {
+        if (this.window.TouchEvent && _(t))
+          try {
+            t.preventDefault(), t.stopPropagation();
+          } catch {
+          }
+        var i = this.props, n = i.maxWidth, a = i.maxHeight, s = i.minWidth, p = i.minHeight, h = _(t) ? t.touches[0].clientX : t.clientX, l = _(t) ? t.touches[0].clientY : t.clientY, d = this.state, b = d.direction, y = d.original, g = d.width, u = d.height, v = this.getParentSize(), w = tt(v, this.window.innerWidth, this.window.innerHeight, n, a, s, p);
+        n = w.maxWidth, a = w.maxHeight, s = w.minWidth, p = w.minHeight;
+        var m = this.calculateNewSizeFromDirection(h, l), f = m.newHeight, c = m.newWidth, R = this.calculateNewMaxFromBoundary(n, a);
+        this.props.snap && this.props.snap.x && (c = j(c, this.props.snap.x, this.props.snapGap)), this.props.snap && this.props.snap.y && (f = j(f, this.props.snap.y, this.props.snapGap));
+        var W = this.calculateNewSizeFromAspectRatio(c, f, { width: R.maxWidth, height: R.maxHeight }, { width: s, height: p });
+        if (c = W.newWidth, f = W.newHeight, this.props.grid) {
+          var M = O(c, this.props.grid[0], this.props.gridGap ? this.props.gridGap[0] : 0), k = O(f, this.props.grid[1], this.props.gridGap ? this.props.gridGap[1] : 0), E = this.props.snapGap || 0, U = E === 0 || Math.abs(M - c) <= E ? M : c, X = E === 0 || Math.abs(k - f) <= E ? k : f;
+          c = U, f = X;
+        }
+        var D = {
+          width: c - y.width,
+          height: f - y.height
+        };
+        if (this.delta = D, g && typeof g == "string") {
+          if (g.endsWith("%")) {
+            var C = c / v.width * 100;
+            c = "".concat(C, "%");
+          } else if (g.endsWith("vw")) {
+            var L = c / this.window.innerWidth * 100;
+            c = "".concat(L, "vw");
+          } else if (g.endsWith("vh")) {
+            var H = c / this.window.innerHeight * 100;
+            c = "".concat(H, "vh");
+          }
+        }
+        if (u && typeof u == "string") {
+          if (u.endsWith("%")) {
+            var C = f / v.height * 100;
+            f = "".concat(C, "%");
+          } else if (u.endsWith("vw")) {
+            var L = f / this.window.innerWidth * 100;
+            f = "".concat(L, "vw");
+          } else if (u.endsWith("vh")) {
+            var H = f / this.window.innerHeight * 100;
+            f = "".concat(H, "vh");
+          }
+        }
+        var S = {
+          width: this.createSizeForCssProperty(c, "width"),
+          height: this.createSizeForCssProperty(f, "height")
+        };
+        this.flexDir === "row" ? S.flexBasis = S.width : this.flexDir === "column" && (S.flexBasis = S.height);
+        var Y = this.state.width !== S.width, G = this.state.height !== S.height, I = this.state.flexBasis !== S.flexBasis, T = Y || G || I;
+        T && q.flushSync(function() {
+          e.setState(S);
+        }), this.props.onResize && T && this.props.onResize(t, b, this.resizable, D);
+      }
+    }, o.prototype.onMouseUp = function(t) {
+      var e, i, n = this.state, a = n.isResizing, s = n.direction;
+      n.original, !(!a || !this.resizable) && (this.props.onResizeStop && this.props.onResizeStop(t, s, this.resizable, this.delta), this.props.size && this.setState({ width: (e = this.props.size.width) !== null && e !== void 0 ? e : "auto", height: (i = this.props.size.height) !== null && i !== void 0 ? i : "auto" }), this.unbindEvents(), this.setState({
+        isResizing: !1,
+        backgroundStyle: z(z({}, this.state.backgroundStyle), { cursor: "auto" })
+      }));
+    }, o.prototype.updateSize = function(t) {
+      var e, i;
+      this.setState({ width: (e = t.width) !== null && e !== void 0 ? e : "auto", height: (i = t.height) !== null && i !== void 0 ? i : "auto" });
+    }, o.prototype.renderResizer = function() {
+      var t = this, e = this.props, i = e.enable, n = e.handleStyles, a = e.handleClasses, s = e.handleWrapperStyle, p = e.handleWrapperClass, h = e.handleComponent;
+      if (!i)
+        return null;
+      var l = Object.keys(i).map(function(d) {
+        return i[d] !== !1 ? A(J, { direction: d, onResizeStart: t.onResizeStart, replaceStyles: n && n[d], className: a && a[d], children: h && h[d] ? h[d] : null }, d) : null;
+      });
+      return A("div", { className: p, style: s, children: l });
+    }, o.prototype.render = function() {
+      var t = this, e = Object.keys(this.props).reduce(function(a, s) {
+        return it.indexOf(s) !== -1 || (a[s] = t.props[s]), a;
+      }, {}), i = z(z(z({ position: "relative", userSelect: this.state.isResizing ? "none" : "auto" }, this.props.style), this.sizeStyle), { maxWidth: this.props.maxWidth, maxHeight: this.props.maxHeight, minWidth: this.props.minWidth, minHeight: this.props.minHeight, boxSizing: "border-box", flexShrink: 0 });
+      this.state.flexBasis && (i.flexBasis = this.state.flexBasis);
+      var n = this.props.as || "div";
+      return V(n, z({ style: i, className: this.props.className }, e, {
+        // `ref` is after `extendsProps` to ensure this one wins over a version
+        // passed in
+        ref: function(a) {
+          a && (t.resizable = a);
+        },
+        children: [this.state.isResizing && A("div", { style: this.state.backgroundStyle }), this.props.children, this.renderResizer()]
+      }));
+    }, o.defaultProps = {
+      as: "div",
+      onResizeStart: function() {
+      },
+      onResize: function() {
+      },
+      onResizeStop: function() {
+      },
+      enable: {
+        top: !0,
+        right: !0,
+        bottom: !0,
+        left: !0,
+        topRight: !0,
+        bottomRight: !0,
+        bottomLeft: !0,
+        topLeft: !0
+      },
+      style: {},
+      grid: [1, 1],
+      gridGap: [0, 0],
+      lockAspectRatio: !1,
+      lockAspectRatioExtraWidth: 0,
+      lockAspectRatioExtraHeight: 0,
+      scale: 1,
+      resizeRatio: 1,
+      snapGap: 0
+    }, o;
+  }(Z)
+);
+export {
+  ht as Resizable
+};

package/dist/node_modules/re-resizable/lib/resizer.js

@@ -0,0 +1,49 @@
+import { jsx as d } from "react/jsx-runtime";
+import { memo as m, useCallback as u, useMemo as g } from "react";
+var e = function() {
+  return e = Object.assign || function(r) {
+    for (var o, t = 1, s = arguments.length; t < s; t++) {
+      o = arguments[t];
+      for (var n in o) Object.prototype.hasOwnProperty.call(o, n) && (r[n] = o[n]);
+    }
+    return r;
+  }, e.apply(this, arguments);
+}, l = {
+  width: "100%",
+  height: "10px",
+  top: "0px",
+  left: "0px",
+  cursor: "row-resize"
+}, c = {
+  width: "10px",
+  height: "100%",
+  top: "0px",
+  left: "0px",
+  cursor: "col-resize"
+}, i = {
+  width: "20px",
+  height: "20px",
+  position: "absolute",
+  zIndex: 1
+}, v = {
+  top: e(e({}, l), { top: "-5px" }),
+  right: e(e({}, c), { left: void 0, right: "-5px" }),
+  bottom: e(e({}, l), { top: void 0, bottom: "-5px" }),
+  left: e(e({}, c), { left: "-5px" }),
+  topRight: e(e({}, i), { right: "-10px", top: "-10px", cursor: "ne-resize" }),
+  bottomRight: e(e({}, i), { right: "-10px", bottom: "-10px", cursor: "se-resize" }),
+  bottomLeft: e(e({}, i), { left: "-10px", bottom: "-10px", cursor: "sw-resize" }),
+  topLeft: e(e({}, i), { left: "-10px", top: "-10px", cursor: "nw-resize" })
+}, w = m(function(r) {
+  var o = r.onResizeStart, t = r.direction, s = r.children, n = r.replaceStyles, p = r.className, f = u(function(a) {
+    o(a, t);
+  }, [o, t]), h = u(function(a) {
+    o(a, t);
+  }, [o, t]), x = g(function() {
+    return e(e({ position: "absolute", userSelect: "none" }, v[t]), n ?? {});
+  }, [n, t]);
+  return d("div", { className: p || void 0, style: x, onMouseDown: f, onTouchStart: h, children: s });
+});
+export {
+  w as Resizer
+};