@spacego/fe-components 0.1.0 → 0.2.0

package/lib/node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/cjs/react-is.production.min.js

@@ -0,0 +1,78 @@
+import { __exports as r } from "../../../../../../_virtual/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.
+ */
+var _;
+function g() {
+  if (_) return r;
+  _ = 1;
+  var t = typeof Symbol == "function" && Symbol.for, a = t ? Symbol.for("react.element") : 60103, b = t ? Symbol.for("react.portal") : 60106, n = t ? Symbol.for("react.fragment") : 60107, c = t ? Symbol.for("react.strict_mode") : 60108, f = t ? Symbol.for("react.profiler") : 60114, i = t ? Symbol.for("react.provider") : 60109, s = t ? Symbol.for("react.context") : 60110, d = t ? Symbol.for("react.async_mode") : 60111, u = t ? Symbol.for("react.concurrent_mode") : 60111, y = t ? Symbol.for("react.forward_ref") : 60112, l = t ? Symbol.for("react.suspense") : 60113, x = t ? Symbol.for("react.suspense_list") : 60120, m = t ? Symbol.for("react.memo") : 60115, p = t ? Symbol.for("react.lazy") : 60116, C = t ? Symbol.for("react.block") : 60121, M = t ? Symbol.for("react.fundamental") : 60117, v = t ? Symbol.for("react.responder") : 60118, w = t ? Symbol.for("react.scope") : 60119;
+  function o(e) {
+    if (typeof e == "object" && e !== null) {
+      var S = e.$$typeof;
+      switch (S) {
+        case a:
+          switch (e = e.type, e) {
+            case d:
+            case u:
+            case n:
+            case f:
+            case c:
+            case l:
+              return e;
+            default:
+              switch (e = e && e.$$typeof, e) {
+                case s:
+                case y:
+                case p:
+                case m:
+                case i:
+                  return e;
+                default:
+                  return S;
+              }
+          }
+        case b:
+          return S;
+      }
+    }
+  }
+  function $(e) {
+    return o(e) === u;
+  }
+  return r.AsyncMode = d, r.ConcurrentMode = u, r.ContextConsumer = s, r.ContextProvider = i, r.Element = a, r.ForwardRef = y, r.Fragment = n, r.Lazy = p, r.Memo = m, r.Portal = b, r.Profiler = f, r.StrictMode = c, r.Suspense = l, r.isAsyncMode = function(e) {
+    return $(e) || o(e) === d;
+  }, r.isConcurrentMode = $, r.isContextConsumer = function(e) {
+    return o(e) === s;
+  }, r.isContextProvider = function(e) {
+    return o(e) === i;
+  }, r.isElement = function(e) {
+    return typeof e == "object" && e !== null && e.$$typeof === a;
+  }, r.isForwardRef = function(e) {
+    return o(e) === y;
+  }, r.isFragment = function(e) {
+    return o(e) === n;
+  }, r.isLazy = function(e) {
+    return o(e) === p;
+  }, r.isMemo = function(e) {
+    return o(e) === m;
+  }, r.isPortal = function(e) {
+    return o(e) === b;
+  }, r.isProfiler = function(e) {
+    return o(e) === f;
+  }, r.isStrictMode = function(e) {
+    return o(e) === c;
+  }, r.isSuspense = function(e) {
+    return o(e) === l;
+  }, r.isValidElementType = function(e) {
+    return typeof e == "string" || typeof e == "function" || e === n || e === u || e === f || e === c || e === l || e === x || typeof e == "object" && e !== null && (e.$$typeof === p || e.$$typeof === m || e.$$typeof === i || e.$$typeof === s || e.$$typeof === y || e.$$typeof === M || e.$$typeof === v || e.$$typeof === w || e.$$typeof === C);
+  }, r.typeOf = o, r;
+}
+export {
+  g as __require
+};

package/lib/node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/index.js

@@ -0,0 +1,10 @@
+import { __module as e } from "../../../../../_virtual/index4.js";
+import { __require as o } from "./cjs/react-is.production.min.js";
+import { __require as t } from "./cjs/react-is.development.js";
+var r;
+function p() {
+  return r ? e.exports : (r = 1, process.env.NODE_ENV === "production" ? e.exports = o() : e.exports = t(), e.exports);
+}
+export {
+  p as __require
+};

package/lib/node_modules/.pnpm/react-resizable@3.1.3_nnrd3gsncyragczmpvfhocinkq/node_modules/react-resizable/build/Resizable.js

@@ -0,0 +1,233 @@
+import { __exports as y } from "../../../../../../_virtual/Resizable.js";
+import T from "react";
+import L from "react-draggable";
+import { __require as I } from "./utils.js";
+import { __require as K } from "./propTypes.js";
+var H;
+function G() {
+  if (H) return y;
+  H = 1, y.__esModule = !0, y.default = void 0;
+  var d = _(T), k = L, w = I(), C = K();
+  const D = ["children", "className", "draggableOpts", "width", "height", "handle", "handleSize", "lockAspectRatio", "axis", "minConstraints", "maxConstraints", "onResize", "onResizeStop", "onResizeStart", "resizeHandles", "transformScale"];
+  function _(s, t) {
+    if (typeof WeakMap == "function") var e = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakMap();
+    return (_ = function(n, i) {
+      if (!i && n && n.__esModule) return n;
+      var o, l, c = { __proto__: null, default: n };
+      if (n === null || typeof n != "object" && typeof n != "function") return c;
+      if (o = i ? r : e) {
+        if (o.has(n)) return o.get(n);
+        o.set(n, c);
+      }
+      for (const a in n) a !== "default" && {}.hasOwnProperty.call(n, a) && ((l = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(n, a)) && (l.get || l.set) ? o(c, a, l) : c[a] = n[a]);
+      return c;
+    })(s, t);
+  }
+  function g() {
+    return g = Object.assign ? Object.assign.bind() : function(s) {
+      for (var t = 1; t < arguments.length; t++) {
+        var e = arguments[t];
+        for (var r in e) ({}).hasOwnProperty.call(e, r) && (s[r] = e[r]);
+      }
+      return s;
+    }, g.apply(null, arguments);
+  }
+  function M(s, t) {
+    if (s == null) return {};
+    var e, r, n = W(s, t);
+    if (Object.getOwnPropertySymbols) {
+      var i = Object.getOwnPropertySymbols(s);
+      for (r = 0; r < i.length; r++) e = i[r], t.indexOf(e) === -1 && {}.propertyIsEnumerable.call(s, e) && (n[e] = s[e]);
+    }
+    return n;
+  }
+  function W(s, t) {
+    if (s == null) return {};
+    var e = {};
+    for (var r in s) if ({}.hasOwnProperty.call(s, r)) {
+      if (t.indexOf(r) !== -1) continue;
+      e[r] = s[r];
+    }
+    return e;
+  }
+  function v(s, t) {
+    var e = Object.keys(s);
+    if (Object.getOwnPropertySymbols) {
+      var r = Object.getOwnPropertySymbols(s);
+      t && (r = r.filter(function(n) {
+        return Object.getOwnPropertyDescriptor(s, n).enumerable;
+      })), e.push.apply(e, r);
+    }
+    return e;
+  }
+  function S(s) {
+    for (var t = 1; t < arguments.length; t++) {
+      var e = arguments[t] != null ? arguments[t] : {};
+      t % 2 ? v(Object(e), !0).forEach(function(r) {
+        q(s, r, e[r]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(s, Object.getOwnPropertyDescriptors(e)) : v(Object(e)).forEach(function(r) {
+        Object.defineProperty(s, r, Object.getOwnPropertyDescriptor(e, r));
+      });
+    }
+    return s;
+  }
+  function q(s, t, e) {
+    return (t = E(t)) in s ? Object.defineProperty(s, t, { value: e, enumerable: !0, configurable: !0, writable: !0 }) : s[t] = e, s;
+  }
+  function E(s) {
+    var t = x(s, "string");
+    return typeof t == "symbol" ? t : t + "";
+  }
+  function x(s, t) {
+    if (typeof s != "object" || !s) return s;
+    var e = s[Symbol.toPrimitive];
+    if (e !== void 0) {
+      var r = e.call(s, t);
+      if (typeof r != "object") return r;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (t === "string" ? String : Number)(s);
+  }
+  let O = class extends d.Component {
+    constructor() {
+      super(...arguments), this.handleRefs = {}, this.lastHandleRect = null, this.slack = null, this.lastSize = null;
+    }
+    componentWillUnmount() {
+      this.resetData();
+    }
+    resetData() {
+      this.lastHandleRect = this.slack = this.lastSize = null;
+    }
+    // Clamp width and height within provided constraints
+    runConstraints(t, e) {
+      const {
+        minConstraints: r,
+        maxConstraints: n,
+        lockAspectRatio: i
+      } = this.props;
+      if (!r && !n && !i) return [t, e];
+      if (i) {
+        const u = this.props.width / this.props.height, m = t - this.props.width, b = e - this.props.height;
+        Math.abs(m) > Math.abs(b * u) ? e = t / u : t = e * u;
+      }
+      const [o, l] = [t, e];
+      let [c, a] = this.slack || [0, 0];
+      return t += c, e += a, r && (t = Math.max(r[0], t), e = Math.max(r[1], e)), n && (t = Math.min(n[0], t), e = Math.min(n[1], e)), this.slack = [c + (o - t), a + (l - e)], [t, e];
+    }
+    /**
+     * Wrapper around drag events to provide more useful data.
+     *
+     * @param  {String} handlerName Handler name to wrap.
+     * @return {Function}           Handler function.
+     */
+    resizeHandler(t, e) {
+      return (r, n) => {
+        var R;
+        let {
+          node: i,
+          deltaX: o,
+          deltaY: l
+        } = n;
+        t === "onResizeStart" && this.resetData();
+        const c = (this.props.axis === "both" || this.props.axis === "x") && e !== "n" && e !== "s", a = (this.props.axis === "both" || this.props.axis === "y") && e !== "e" && e !== "w";
+        if (!c && !a) return;
+        const u = e[0], m = e[e.length - 1], b = i.getBoundingClientRect();
+        if (this.lastHandleRect != null) {
+          if (m === "w") {
+            const p = b.left - this.lastHandleRect.left;
+            o += p;
+          }
+          if (u === "n") {
+            const p = b.top - this.lastHandleRect.top;
+            l += p;
+          }
+        }
+        this.lastHandleRect = b, m === "w" && (o = -o), u === "n" && (l = -l);
+        let f = this.props.width + (c ? o / this.props.transformScale : 0), h = this.props.height + (a ? l / this.props.transformScale : 0);
+        [f, h] = this.runConstraints(f, h), t === "onResizeStop" && this.lastSize && ({
+          width: f,
+          height: h
+        } = this.lastSize);
+        const P = f !== this.props.width || h !== this.props.height;
+        t !== "onResizeStop" && (this.lastSize = {
+          width: f,
+          height: h
+        });
+        const z = typeof this.props[t] == "function" ? this.props[t] : null;
+        z && !(t === "onResize" && !P) && ((R = r.persist) == null || R.call(r), z(r, {
+          node: i,
+          size: {
+            width: f,
+            height: h
+          },
+          handle: e
+        })), t === "onResizeStop" && this.resetData();
+      };
+    }
+    // Render a resize handle given an axis & DOM ref. Ref *must* be attached for
+    // the underlying draggable library to work properly.
+    renderResizeHandle(t, e) {
+      const {
+        handle: r
+      } = this.props;
+      if (!r)
+        return /* @__PURE__ */ d.createElement("span", {
+          className: `react-resizable-handle react-resizable-handle-${t}`,
+          ref: e
+        });
+      if (typeof r == "function")
+        return r(t, e);
+      const n = typeof r.type == "string", i = S({
+        ref: e
+      }, n ? {} : {
+        handleAxis: t
+      });
+      return /* @__PURE__ */ d.cloneElement(r, i);
+    }
+    render() {
+      const t = this.props, {
+        children: e,
+        className: r,
+        draggableOpts: n,
+        width: i,
+        height: o,
+        handle: l,
+        handleSize: c,
+        lockAspectRatio: a,
+        axis: u,
+        minConstraints: m,
+        maxConstraints: b,
+        onResize: f,
+        onResizeStop: h,
+        onResizeStart: P,
+        resizeHandles: z,
+        transformScale: $
+      } = t, R = M(t, D);
+      return (0, w.cloneElement)(e, S(S({}, R), {}, {
+        className: `${r ? `${r} ` : ""}react-resizable`,
+        children: [...d.Children.toArray(e.props.children), ...z.map((p) => {
+          const j = this.handleRefs[p] ?? (this.handleRefs[p] = /* @__PURE__ */ d.createRef());
+          return /* @__PURE__ */ d.createElement(k.DraggableCore, g({}, n, {
+            nodeRef: j,
+            key: `resizableHandle-${p}`,
+            onStop: this.resizeHandler("onResizeStop", p),
+            onStart: this.resizeHandler("onResizeStart", p),
+            onDrag: this.resizeHandler("onResize", p)
+          }), this.renderResizeHandle(p, j));
+        })]
+      }));
+    }
+  };
+  return y.default = O, O.propTypes = C.resizableProps, O.defaultProps = {
+    axis: "both",
+    handleSize: [20, 20],
+    lockAspectRatio: !1,
+    minConstraints: [20, 20],
+    maxConstraints: [1 / 0, 1 / 0],
+    resizeHandles: ["se"],
+    transformScale: 1
+  }, y;
+}
+export {
+  G as __require
+};

package/lib/node_modules/.pnpm/react-resizable@3.1.3_nnrd3gsncyragczmpvfhocinkq/node_modules/react-resizable/build/ResizableBox.js

@@ -0,0 +1,164 @@
+import { __exports as l } from "../../../../../../_virtual/ResizableBox.js";
+import E from "react";
+import { __require as H } from "../../../../prop-types@15.8.1/node_modules/prop-types/index.js";
+import { __require as M } from "./Resizable.js";
+import { __require as T } from "./propTypes.js";
+var y;
+function G() {
+  if (y) return l;
+  y = 1, l.__esModule = !0, l.default = void 0;
+  var c = g(E), _ = d(/* @__PURE__ */ H()), O = d(M()), v = T();
+  const w = ["handle", "handleSize", "onResize", "onResizeStart", "onResizeStop", "draggableOpts", "minConstraints", "maxConstraints", "lockAspectRatio", "axis", "width", "height", "resizeHandles", "style", "transformScale"];
+  function d(t) {
+    return t && t.__esModule ? t : { default: t };
+  }
+  function g(t, e) {
+    if (typeof WeakMap == "function") var r = /* @__PURE__ */ new WeakMap(), i = /* @__PURE__ */ new WeakMap();
+    return (g = function(n, a) {
+      if (!a && n && n.__esModule) return n;
+      var o, u, p = { __proto__: null, default: n };
+      if (n === null || typeof n != "object" && typeof n != "function") return p;
+      if (o = a ? i : r) {
+        if (o.has(n)) return o.get(n);
+        o.set(n, p);
+      }
+      for (const s in n) s !== "default" && {}.hasOwnProperty.call(n, s) && ((u = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(n, s)) && (u.get || u.set) ? o(p, s, u) : p[s] = n[s]);
+      return p;
+    })(t, e);
+  }
+  function f() {
+    return f = Object.assign ? Object.assign.bind() : function(t) {
+      for (var e = 1; e < arguments.length; e++) {
+        var r = arguments[e];
+        for (var i in r) ({}).hasOwnProperty.call(r, i) && (t[i] = r[i]);
+      }
+      return t;
+    }, f.apply(null, arguments);
+  }
+  function b(t, e) {
+    var r = Object.keys(t);
+    if (Object.getOwnPropertySymbols) {
+      var i = Object.getOwnPropertySymbols(t);
+      e && (i = i.filter(function(n) {
+        return Object.getOwnPropertyDescriptor(t, n).enumerable;
+      })), r.push.apply(r, i);
+    }
+    return r;
+  }
+  function h(t) {
+    for (var e = 1; e < arguments.length; e++) {
+      var r = arguments[e] != null ? arguments[e] : {};
+      e % 2 ? b(Object(r), !0).forEach(function(i) {
+        z(t, i, r[i]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(r)) : b(Object(r)).forEach(function(i) {
+        Object.defineProperty(t, i, Object.getOwnPropertyDescriptor(r, i));
+      });
+    }
+    return t;
+  }
+  function z(t, e, r) {
+    return (e = R(e)) in t ? Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : t[e] = r, t;
+  }
+  function R(t) {
+    var e = P(t, "string");
+    return typeof e == "symbol" ? e : e + "";
+  }
+  function P(t, e) {
+    if (typeof t != "object" || !t) return t;
+    var r = t[Symbol.toPrimitive];
+    if (r !== void 0) {
+      var i = r.call(t, e);
+      if (typeof i != "object") return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (e === "string" ? String : Number)(t);
+  }
+  function j(t, e) {
+    if (t == null) return {};
+    var r, i, n = S(t, e);
+    if (Object.getOwnPropertySymbols) {
+      var a = Object.getOwnPropertySymbols(t);
+      for (i = 0; i < a.length; i++) r = a[i], e.indexOf(r) === -1 && {}.propertyIsEnumerable.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }
+  function S(t, e) {
+    if (t == null) return {};
+    var r = {};
+    for (var i in t) if ({}.hasOwnProperty.call(t, i)) {
+      if (e.indexOf(i) !== -1) continue;
+      r[i] = t[i];
+    }
+    return r;
+  }
+  let m = class extends c.Component {
+    constructor() {
+      super(...arguments), this.state = {
+        width: this.props.width,
+        height: this.props.height,
+        propsWidth: this.props.width,
+        propsHeight: this.props.height
+      }, this.onResize = (e, r) => {
+        var n;
+        const {
+          size: i
+        } = r;
+        this.props.onResize ? ((n = e.persist) == null || n.call(e), this.setState(i, () => this.props.onResize && this.props.onResize(e, r))) : this.setState(i);
+      };
+    }
+    static getDerivedStateFromProps(e, r) {
+      return r.propsWidth !== e.width || r.propsHeight !== e.height ? {
+        width: e.width,
+        height: e.height,
+        propsWidth: e.width,
+        propsHeight: e.height
+      } : null;
+    }
+    render() {
+      const e = this.props, {
+        handle: r,
+        handleSize: i,
+        onResize: n,
+        onResizeStart: a,
+        onResizeStop: o,
+        draggableOpts: u,
+        minConstraints: p,
+        maxConstraints: s,
+        lockAspectRatio: x,
+        axis: q,
+        width: B,
+        height: A,
+        resizeHandles: W,
+        style: k,
+        transformScale: C
+      } = e, D = j(e, w);
+      return /* @__PURE__ */ c.createElement(O.default, {
+        axis: q,
+        draggableOpts: u,
+        handle: r,
+        handleSize: i,
+        height: this.state.height,
+        lockAspectRatio: x,
+        maxConstraints: s,
+        minConstraints: p,
+        onResizeStart: a,
+        onResize: this.onResize,
+        onResizeStop: o,
+        resizeHandles: W,
+        transformScale: C,
+        width: this.state.width
+      }, /* @__PURE__ */ c.createElement("div", f({}, D, {
+        style: h(h({}, k), {}, {
+          width: this.state.width + "px",
+          height: this.state.height + "px"
+        })
+      })));
+    }
+  };
+  return l.default = m, m.propTypes = h(h({}, v.resizableProps), {}, {
+    children: _.default.element
+  }), l;
+}
+export {
+  G as __require
+};

package/lib/node_modules/.pnpm/react-resizable@3.1.3_nnrd3gsncyragczmpvfhocinkq/node_modules/react-resizable/build/propTypes.js

@@ -0,0 +1,113 @@
+import { __exports as n } from "../../../../../../_virtual/propTypes.js";
+import { __require as o } from "../../../../prop-types@15.8.1/node_modules/prop-types/index.js";
+import "react-draggable";
+var f;
+function p() {
+  if (f) return n;
+  f = 1, n.__esModule = !0, n.resizableProps = void 0;
+  var e = l(/* @__PURE__ */ o());
+  function l(t) {
+    return t && t.__esModule ? t : { default: t };
+  }
+  return n.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: e.default.oneOf(["both", "x", "y", "none"]),
+    className: e.default.string,
+    /*
+    * Require that one and only one child be present.
+    * */
+    children: e.default.element.isRequired,
+    /*
+    * These will be passed wholesale to react-draggable's DraggableCore
+    * */
+    draggableOpts: e.default.shape({
+      allowAnyClick: e.default.bool,
+      cancel: e.default.string,
+      children: e.default.node,
+      disabled: e.default.bool,
+      enableUserSelectHack: e.default.bool,
+      // #251: Check for Element to support SSR environments where DOM globals don't exist
+      offsetParent: typeof Element < "u" ? e.default.instanceOf(Element) : e.default.any,
+      grid: e.default.arrayOf(e.default.number),
+      handle: e.default.string,
+      nodeRef: e.default.object,
+      onStart: e.default.func,
+      onDrag: e.default.func,
+      onStop: e.default.func,
+      onMouseDown: e.default.func,
+      scale: e.default.number
+    }),
+    /*
+    * Initial height
+    * */
+    height: function() {
+      for (var t = arguments.length, a = new Array(t), r = 0; r < t; r++)
+        a[r] = arguments[r];
+      const [u] = a;
+      return u.axis === "both" || u.axis === "y" ? e.default.number.isRequired(...a) : e.default.number(...a);
+    },
+    /*
+    * Customize cursor resize handle
+    * */
+    handle: e.default.oneOfType([e.default.node, e.default.func]),
+    /*
+    * If you change this, be sure to update your css
+    * */
+    handleSize: e.default.arrayOf(e.default.number),
+    lockAspectRatio: e.default.bool,
+    /*
+    * Max X & Y measure
+    * */
+    maxConstraints: e.default.arrayOf(e.default.number),
+    /*
+    * Min X & Y measure
+    * */
+    minConstraints: e.default.arrayOf(e.default.number),
+    /*
+    * Called on stop resize event
+    * */
+    onResizeStop: e.default.func,
+    /*
+    * Called on start resize event
+    * */
+    onResizeStart: e.default.func,
+    /*
+    * Called on resize event
+    * */
+    onResize: e.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: e.default.arrayOf(e.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: e.default.number,
+    /*
+     * Initial width
+     */
+    width: function() {
+      for (var t = arguments.length, a = new Array(t), r = 0; r < t; r++)
+        a[r] = arguments[r];
+      const [u] = a;
+      return u.axis === "both" || u.axis === "x" ? e.default.number.isRequired(...a) : e.default.number(...a);
+    }
+  }, n;
+}
+export {
+  p as __require
+};

package/lib/node_modules/.pnpm/react-resizable@3.1.3_nnrd3gsncyragczmpvfhocinkq/node_modules/react-resizable/build/utils.js

@@ -0,0 +1,56 @@
+import { __exports as i } from "../../../../../../_virtual/utils.js";
+import m from "react";
+var c;
+function _() {
+  if (c) return i;
+  c = 1, i.__esModule = !0, i.cloneElement = p;
+  var a = s(m);
+  function s(e) {
+    return e && e.__esModule ? e : { default: e };
+  }
+  function o(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var n = Object.getOwnPropertySymbols(e);
+      r && (n = n.filter(function(b) {
+        return Object.getOwnPropertyDescriptor(e, b).enumerable;
+      })), t.push.apply(t, n);
+    }
+    return t;
+  }
+  function u(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = arguments[r] != null ? arguments[r] : {};
+      r % 2 ? o(Object(t), !0).forEach(function(n) {
+        l(e, n, t[n]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : o(Object(t)).forEach(function(n) {
+        Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+      });
+    }
+    return e;
+  }
+  function l(e, r, t) {
+    return (r = f(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e;
+  }
+  function f(e) {
+    var r = y(e, "string");
+    return typeof r == "symbol" ? r : r + "";
+  }
+  function y(e, r) {
+    if (typeof e != "object" || !e) return e;
+    var t = e[Symbol.toPrimitive];
+    if (t !== void 0) {
+      var n = t.call(e, r);
+      if (typeof n != "object") return n;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (r === "string" ? String : Number)(e);
+  }
+  function p(e, r) {
+    return r.style && e.props.style && (r.style = u(u({}, e.props.style), r.style)), r.className && e.props.className && (r.className = `${e.props.className} ${r.className}`), /* @__PURE__ */ a.default.cloneElement(e, r);
+  }
+  return i;
+}
+export {
+  _ as __require
+};

package/lib/node_modules/.pnpm/react-resizable@3.1.3_nnrd3gsncyragczmpvfhocinkq/node_modules/react-resizable/index.js

@@ -0,0 +1,12 @@
+import { __module as e } from "../../../../../_virtual/index2.js";
+import { __require as i } from "./build/Resizable.js";
+import { __require as t } from "./build/ResizableBox.js";
+var r;
+function u() {
+  return r ? e.exports : (r = 1, e.exports = function() {
+    throw new Error("Don't instantiate Resizable directly! Use require('react-resizable').Resizable");
+  }, e.exports.Resizable = i().default, e.exports.ResizableBox = t().default, e.exports);
+}
+export {
+  u as __require
+};