@jeevandev/flow-canvas 0.0.1

package/dist/flow-canvas.es.js

@@ -0,0 +1,3034 @@
+import re, { createContext as qt, useContext as ht, useRef as ve, useEffect as ie, useState as Le, useCallback as ge, useMemo as tt } from "react";
+var Ae = { exports: {} }, Ee = {};
+var Et;
+function bn() {
+  if (Et) return Ee;
+  Et = 1;
+  var t = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function n(s, r, i) {
+    var o = null;
+    if (i !== void 0 && (o = "" + i), r.key !== void 0 && (o = "" + r.key), "key" in r) {
+      i = {};
+      for (var a in r)
+        a !== "key" && (i[a] = r[a]);
+    } else i = r;
+    return r = i.ref, {
+      $$typeof: t,
+      type: s,
+      key: o,
+      ref: r !== void 0 ? r : null,
+      props: i
+    };
+  }
+  return Ee.Fragment = e, Ee.jsx = n, Ee.jsxs = n, Ee;
+}
+var Se = {};
+var St;
+function wn() {
+  return St || (St = 1, process.env.NODE_ENV !== "production" && (function() {
+    function t(u) {
+      if (u == null) return null;
+      if (typeof u == "function")
+        return u.$$typeof === M ? null : u.displayName || u.name || null;
+      if (typeof u == "string") return u;
+      switch (u) {
+        case c:
+          return "Fragment";
+        case p:
+          return "Profiler";
+        case g:
+          return "StrictMode";
+        case h:
+          return "Suspense";
+        case D:
+          return "SuspenseList";
+        case S:
+          return "Activity";
+      }
+      if (typeof u == "object")
+        switch (typeof u.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), u.$$typeof) {
+          case R:
+            return "Portal";
+          case _:
+            return u.displayName || "Context";
+          case b:
+            return (u._context.displayName || "Context") + ".Consumer";
+          case k:
+            var N = u.render;
+            return u = u.displayName, u || (u = N.displayName || N.name || "", u = u !== "" ? "ForwardRef(" + u + ")" : "ForwardRef"), u;
+          case T:
+            return N = u.displayName || null, N !== null ? N : t(u.type) || "Memo";
+          case I:
+            N = u._payload, u = u._init;
+            try {
+              return t(u(N));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function e(u) {
+      return "" + u;
+    }
+    function n(u) {
+      try {
+        e(u);
+        var N = !1;
+      } catch {
+        N = !0;
+      }
+      if (N) {
+        N = console;
+        var H = N.error, B = typeof Symbol == "function" && Symbol.toStringTag && u[Symbol.toStringTag] || u.constructor.name || "Object";
+        return H.call(
+          N,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          B
+        ), e(u);
+      }
+    }
+    function s(u) {
+      if (u === c) return "<>";
+      if (typeof u == "object" && u !== null && u.$$typeof === I)
+        return "<...>";
+      try {
+        var N = t(u);
+        return N ? "<" + N + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function r() {
+      var u = j.A;
+      return u === null ? null : u.getOwner();
+    }
+    function i() {
+      return Error("react-stack-top-frame");
+    }
+    function o(u) {
+      if (x.call(u, "key")) {
+        var N = Object.getOwnPropertyDescriptor(u, "key").get;
+        if (N && N.isReactWarning) return !1;
+      }
+      return u.key !== void 0;
+    }
+    function a(u, N) {
+      function H() {
+        K || (K = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          N
+        ));
+      }
+      H.isReactWarning = !0, Object.defineProperty(u, "key", {
+        get: H,
+        configurable: !0
+      });
+    }
+    function l() {
+      var u = t(this.type);
+      return L[u] || (L[u] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), u = this.props.ref, u !== void 0 ? u : null;
+    }
+    function d(u, N, H, B, me, E) {
+      var A = H.ref;
+      return u = {
+        $$typeof: O,
+        type: u,
+        key: N,
+        props: H,
+        _owner: B
+      }, (A !== void 0 ? A : null) !== null ? Object.defineProperty(u, "ref", {
+        enumerable: !1,
+        get: l
+      }) : Object.defineProperty(u, "ref", { enumerable: !1, value: null }), u._store = {}, Object.defineProperty(u._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(u, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(u, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: me
+      }), Object.defineProperty(u, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: E
+      }), Object.freeze && (Object.freeze(u.props), Object.freeze(u)), u;
+    }
+    function f(u, N, H, B, me, E) {
+      var A = N.children;
+      if (A !== void 0)
+        if (B)
+          if (U(A)) {
+            for (B = 0; B < A.length; B++)
+              v(A[B]);
+            Object.freeze && Object.freeze(A);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else v(A);
+      if (x.call(N, "key")) {
+        A = t(u);
+        var W = Object.keys(N).filter(function(Z) {
+          return Z !== "key";
+        });
+        B = 0 < W.length ? "{key: someKey, " + W.join(": ..., ") + ": ...}" : "{key: someKey}", te[A + B] || (W = 0 < W.length ? "{" + W.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          B,
+          A,
+          W,
+          A
+        ), te[A + B] = !0);
+      }
+      if (A = null, H !== void 0 && (n(H), A = "" + H), o(N) && (n(N.key), A = "" + N.key), "key" in N) {
+        H = {};
+        for (var z in N)
+          z !== "key" && (H[z] = N[z]);
+      } else H = N;
+      return A && a(
+        H,
+        typeof u == "function" ? u.displayName || u.name || "Unknown" : u
+      ), d(
+        u,
+        A,
+        H,
+        r(),
+        me,
+        E
+      );
+    }
+    function v(u) {
+      m(u) ? u._store && (u._store.validated = 1) : typeof u == "object" && u !== null && u.$$typeof === I && (u._payload.status === "fulfilled" ? m(u._payload.value) && u._payload.value._store && (u._payload.value._store.validated = 1) : u._store && (u._store.validated = 1));
+    }
+    function m(u) {
+      return typeof u == "object" && u !== null && u.$$typeof === O;
+    }
+    var w = re, O = Symbol.for("react.transitional.element"), R = Symbol.for("react.portal"), c = Symbol.for("react.fragment"), g = Symbol.for("react.strict_mode"), p = Symbol.for("react.profiler"), b = Symbol.for("react.consumer"), _ = Symbol.for("react.context"), k = Symbol.for("react.forward_ref"), h = Symbol.for("react.suspense"), D = Symbol.for("react.suspense_list"), T = Symbol.for("react.memo"), I = Symbol.for("react.lazy"), S = Symbol.for("react.activity"), M = Symbol.for("react.client.reference"), j = w.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, x = Object.prototype.hasOwnProperty, U = Array.isArray, G = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    w = {
+      react_stack_bottom_frame: function(u) {
+        return u();
+      }
+    };
+    var K, L = {}, F = w.react_stack_bottom_frame.bind(
+      w,
+      i
+    )(), ue = G(s(i)), te = {};
+    Se.Fragment = c, Se.jsx = function(u, N, H) {
+      var B = 1e4 > j.recentlyCreatedOwnerStacks++;
+      return f(
+        u,
+        N,
+        H,
+        !1,
+        B ? Error("react-stack-top-frame") : F,
+        B ? G(s(u)) : ue
+      );
+    }, Se.jsxs = function(u, N, H) {
+      var B = 1e4 > j.recentlyCreatedOwnerStacks++;
+      return f(
+        u,
+        N,
+        H,
+        !0,
+        B ? Error("react-stack-top-frame") : F,
+        B ? G(s(u)) : ue
+      );
+    };
+  })()), Se;
+}
+var Tt;
+function xn() {
+  return Tt || (Tt = 1, process.env.NODE_ENV === "production" ? Ae.exports = bn() : Ae.exports = wn()), Ae.exports;
+}
+var y = xn();
+const It = (t) => {
+  let e;
+  const n = /* @__PURE__ */ new Set(), s = (d, f) => {
+    const v = typeof d == "function" ? d(e) : d;
+    if (!Object.is(v, e)) {
+      const m = e;
+      e = f ?? (typeof v != "object" || v === null) ? v : Object.assign({}, e, v), n.forEach((w) => w(e, m));
+    }
+  }, r = () => e, a = { setState: s, getState: r, getInitialState: () => l, subscribe: (d) => (n.add(d), () => n.delete(d)) }, l = e = t(s, r, a);
+  return a;
+}, En = ((t) => t ? It(t) : It), Sn = (t) => t;
+function Tn(t, e = Sn) {
+  const n = re.useSyncExternalStore(
+    t.subscribe,
+    re.useCallback(() => e(t.getState()), [t, e]),
+    re.useCallback(() => e(t.getInitialState()), [t, e])
+  );
+  return re.useDebugValue(n), n;
+}
+var Jt = Symbol.for("immer-nothing"), Pt = Symbol.for("immer-draftable"), q = Symbol.for("immer-state"), In = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(t) {
+    return `The plugin for '${t}' has not been loaded into Immer. To enable the plugin, import and call \`enable${t}()\` when initializing your application.`;
+  },
+  function(t) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${t}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(t) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + t;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(t) {
+    return `'current' expects a draft, got: ${t}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(t) {
+    return `'original' expects a draft, got: ${t}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function Q(t, ...e) {
+  if (process.env.NODE_ENV !== "production") {
+    const n = In[t], s = he(n) ? n.apply(null, e) : n;
+    throw new Error(`[Immer] ${s}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${t}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var ee = Object, be = ee.getPrototypeOf, $e = "constructor", Be = "prototype", nt = "configurable", He = "enumerable", Me = "writable", Te = "value", fe = (t) => !!t && !!t[q];
+function le(t) {
+  return t ? Zt(t) || Xe(t) || !!t[Pt] || !!t[$e]?.[Pt] || We(t) || Ke(t) : !1;
+}
+var Pn = ee[Be][$e].toString(), kt = /* @__PURE__ */ new WeakMap();
+function Zt(t) {
+  if (!t || !pt(t))
+    return !1;
+  const e = be(t);
+  if (e === null || e === ee[Be])
+    return !0;
+  const n = ee.hasOwnProperty.call(e, $e) && e[$e];
+  if (n === Object)
+    return !0;
+  if (!he(n))
+    return !1;
+  let s = kt.get(n);
+  return s === void 0 && (s = Function.toString.call(n), kt.set(n, s)), s === Pn;
+}
+function ke(t, e, n = !0) {
+  De(t) === 0 ? (n ? Reflect.ownKeys(t) : ee.keys(t)).forEach((r) => {
+    e(r, t[r], t);
+  }) : t.forEach((s, r) => e(r, s, t));
+}
+function De(t) {
+  const e = t[q];
+  return e ? e.type_ : Xe(t) ? 1 : We(t) ? 2 : Ke(t) ? 3 : 0;
+}
+var Dt = (t, e, n = De(t)) => n === 2 ? t.has(e) : ee[Be].hasOwnProperty.call(t, e), st = (t, e, n = De(t)) => (
+  // @ts-ignore
+  n === 2 ? t.get(e) : t[e]
+), Ve = (t, e, n, s = De(t)) => {
+  s === 2 ? t.set(e, n) : s === 3 ? t.add(n) : t[e] = n;
+};
+function kn(t, e) {
+  return t === e ? t !== 0 || 1 / t === 1 / e : t !== t && e !== e;
+}
+var Xe = Array.isArray, We = (t) => t instanceof Map, Ke = (t) => t instanceof Set, pt = (t) => typeof t == "object", he = (t) => typeof t == "function", Ze = (t) => typeof t == "boolean", ce = (t) => t.copy_ || t.base_, mt = (t) => t.modified_ ? t.copy_ : t.base_;
+function rt(t, e) {
+  if (We(t))
+    return new Map(t);
+  if (Ke(t))
+    return new Set(t);
+  if (Xe(t))
+    return Array[Be].slice.call(t);
+  const n = Zt(t);
+  if (e === !0 || e === "class_only" && !n) {
+    const s = ee.getOwnPropertyDescriptors(t);
+    delete s[q];
+    let r = Reflect.ownKeys(s);
+    for (let i = 0; i < r.length; i++) {
+      const o = r[i], a = s[o];
+      a[Me] === !1 && (a[Me] = !0, a[nt] = !0), (a.get || a.set) && (s[o] = {
+        [nt]: !0,
+        [Me]: !0,
+        // could live with !!desc.set as well here...
+        [He]: a[He],
+        [Te]: t[o]
+      });
+    }
+    return ee.create(be(t), s);
+  } else {
+    const s = be(t);
+    if (s !== null && n)
+      return { ...t };
+    const r = ee.create(s);
+    return ee.assign(r, t);
+  }
+}
+function gt(t, e = !1) {
+  return Ge(t) || fe(t) || !le(t) || (De(t) > 1 && ee.defineProperties(t, {
+    set: Ce,
+    add: Ce,
+    clear: Ce,
+    delete: Ce
+  }), ee.freeze(t), e && ke(
+    t,
+    (n, s) => {
+      gt(s, !0);
+    },
+    !1
+  )), t;
+}
+function Dn() {
+  Q(2);
+}
+var Ce = {
+  [Te]: Dn
+};
+function Ge(t) {
+  return t === null || !pt(t) ? !0 : ee.isFrozen(t);
+}
+var Ye = "MapSet", it = "Patches", Qt = {};
+function we(t) {
+  const e = Qt[t];
+  return e || Q(0, t), e;
+}
+var On = (t) => !!Qt[t], Ie, en = () => Ie, Rn = (t, e) => ({
+  drafts_: [],
+  parent_: t,
+  immer_: e,
+  // Whenever the modified draft contains a draft from another scope, we
+  // need to prevent auto-freezing so the unowned draft can be finalized.
+  canAutoFreeze_: !0,
+  unfinalizedDrafts_: 0,
+  handledSet_: /* @__PURE__ */ new Set(),
+  processedForPatches_: /* @__PURE__ */ new Set(),
+  mapSetPlugin_: On(Ye) ? we(Ye) : void 0
+});
+function Ot(t, e) {
+  e && (t.patchPlugin_ = we(it), t.patches_ = [], t.inversePatches_ = [], t.patchListener_ = e);
+}
+function ot(t) {
+  at(t), t.drafts_.forEach(Nn), t.drafts_ = null;
+}
+function at(t) {
+  t === Ie && (Ie = t.parent_);
+}
+var Rt = (t) => Ie = Rn(Ie, t);
+function Nn(t) {
+  const e = t[q];
+  e.type_ === 0 || e.type_ === 1 ? e.revoke_() : e.revoked_ = !0;
+}
+function Nt(t, e) {
+  e.unfinalizedDrafts_ = e.drafts_.length;
+  const n = e.drafts_[0];
+  if (t !== void 0 && t !== n) {
+    n[q].modified_ && (ot(e), Q(4)), le(t) && (t = At(e, t));
+    const { patchPlugin_: r } = e;
+    r && r.generateReplacementPatches_(
+      n[q].base_,
+      t,
+      e
+    );
+  } else
+    t = At(e, n);
+  return An(e, t, !0), ot(e), e.patches_ && e.patchListener_(e.patches_, e.inversePatches_), t !== Jt ? t : void 0;
+}
+function At(t, e) {
+  if (Ge(e))
+    return e;
+  const n = e[q];
+  if (!n)
+    return yt(e, t.handledSet_, t);
+  if (!qe(n, t))
+    return e;
+  if (!n.modified_)
+    return n.base_;
+  if (!n.finalized_) {
+    const { callbacks_: s } = n;
+    if (s)
+      for (; s.length > 0; )
+        s.pop()(t);
+    sn(n, t);
+  }
+  return n.copy_;
+}
+function An(t, e, n = !1) {
+  !t.parent_ && t.immer_.autoFreeze_ && t.canAutoFreeze_ && gt(e, n);
+}
+function tn(t) {
+  t.finalized_ = !0, t.scope_.unfinalizedDrafts_--;
+}
+var qe = (t, e) => t.scope_ === e, Cn = [];
+function nn(t, e, n, s) {
+  const r = ce(t), i = t.type_;
+  if (s !== void 0 && st(r, s, i) === e) {
+    Ve(r, s, n, i);
+    return;
+  }
+  if (!t.draftLocations_) {
+    const a = t.draftLocations_ = /* @__PURE__ */ new Map();
+    ke(r, (l, d) => {
+      if (fe(d)) {
+        const f = a.get(d) || [];
+        f.push(l), a.set(d, f);
+      }
+    });
+  }
+  const o = t.draftLocations_.get(e) ?? Cn;
+  for (const a of o)
+    Ve(r, a, n, i);
+}
+function Mn(t, e, n) {
+  t.callbacks_.push(function(r) {
+    const i = e;
+    if (!i || !qe(i, r))
+      return;
+    r.mapSetPlugin_?.fixSetContents(i);
+    const o = mt(i);
+    nn(t, i.draft_ ?? i, o, n), sn(i, r);
+  });
+}
+function sn(t, e) {
+  if (t.modified_ && !t.finalized_ && (t.type_ === 3 || (t.assigned_?.size ?? 0) > 0)) {
+    const { patchPlugin_: s } = e;
+    if (s) {
+      const r = s.getPath(t);
+      r && s.generatePatches_(t, r, e);
+    }
+    tn(t);
+  }
+}
+function jn(t, e, n) {
+  const { scope_: s } = t;
+  if (fe(n)) {
+    const r = n[q];
+    qe(r, s) && r.callbacks_.push(function() {
+      je(t);
+      const o = mt(r);
+      nn(t, n, o, e);
+    });
+  } else le(n) && t.callbacks_.push(function() {
+    const i = ce(t);
+    st(i, e, t.type_) === n && s.drafts_.length > 1 && (t.assigned_.get(e) ?? !1) === !0 && t.copy_ && yt(
+      st(t.copy_, e, t.type_),
+      s.handledSet_,
+      s
+    );
+  });
+}
+function yt(t, e, n) {
+  return !n.immer_.autoFreeze_ && n.unfinalizedDrafts_ < 1 || fe(t) || e.has(t) || !le(t) || Ge(t) || (e.add(t), ke(t, (s, r) => {
+    if (fe(r)) {
+      const i = r[q];
+      if (qe(i, n)) {
+        const o = mt(i);
+        Ve(t, s, o, t.type_), tn(i);
+      }
+    } else le(r) && yt(r, e, n);
+  })), t;
+}
+function zn(t, e) {
+  const n = Xe(t), s = {
+    type_: n ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: e ? e.scope_ : en(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    // actually instantiated in `prepareCopy()`
+    assigned_: void 0,
+    // The parent draft state.
+    parent_: e,
+    // The base state.
+    base_: t,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1,
+    // `callbacks` actually gets assigned in `createProxy`
+    callbacks_: void 0
+  };
+  let r = s, i = _t;
+  n && (r = [s], i = Pe);
+  const { revoke: o, proxy: a } = Proxy.revocable(r, i);
+  return s.draft_ = a, s.revoke_ = o, [a, s];
+}
+var _t = {
+  get(t, e) {
+    if (e === q)
+      return t;
+    const n = ce(t);
+    if (!Dt(n, e, t.type_))
+      return Ln(t, n, e);
+    const s = n[e];
+    if (t.finalized_ || !le(s))
+      return s;
+    if (s === Qe(t.base_, e)) {
+      je(t);
+      const r = t.type_ === 1 ? +e : e, i = lt(t.scope_, s, t, r);
+      return t.copy_[r] = i;
+    }
+    return s;
+  },
+  has(t, e) {
+    return e in ce(t);
+  },
+  ownKeys(t) {
+    return Reflect.ownKeys(ce(t));
+  },
+  set(t, e, n) {
+    const s = rn(ce(t), e);
+    if (s?.set)
+      return s.set.call(t.draft_, n), !0;
+    if (!t.modified_) {
+      const r = Qe(ce(t), e), i = r?.[q];
+      if (i && i.base_ === n)
+        return t.copy_[e] = n, t.assigned_.set(e, !1), !0;
+      if (kn(n, r) && (n !== void 0 || Dt(t.base_, e, t.type_)))
+        return !0;
+      je(t), ct(t);
+    }
+    return t.copy_[e] === n && // special case: handle new props with value 'undefined'
+    (n !== void 0 || e in t.copy_) || // special case: NaN
+    Number.isNaN(n) && Number.isNaN(t.copy_[e]) || (t.copy_[e] = n, t.assigned_.set(e, !0), jn(t, e, n)), !0;
+  },
+  deleteProperty(t, e) {
+    return je(t), Qe(t.base_, e) !== void 0 || e in t.base_ ? (t.assigned_.set(e, !1), ct(t)) : t.assigned_.delete(e), t.copy_ && delete t.copy_[e], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(t, e) {
+    const n = ce(t), s = Reflect.getOwnPropertyDescriptor(n, e);
+    return s && {
+      [Me]: !0,
+      [nt]: t.type_ !== 1 || e !== "length",
+      [He]: s[He],
+      [Te]: n[e]
+    };
+  },
+  defineProperty() {
+    Q(11);
+  },
+  getPrototypeOf(t) {
+    return be(t.base_);
+  },
+  setPrototypeOf() {
+    Q(12);
+  }
+}, Pe = {};
+ke(_t, (t, e) => {
+  Pe[t] = function() {
+    const n = arguments;
+    return n[0] = n[0][0], e.apply(this, n);
+  };
+});
+Pe.deleteProperty = function(t, e) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(e)) && Q(13), Pe.set.call(this, t, e, void 0);
+};
+Pe.set = function(t, e, n) {
+  return process.env.NODE_ENV !== "production" && e !== "length" && isNaN(parseInt(e)) && Q(14), _t.set.call(this, t[0], e, n, t[0]);
+};
+function Qe(t, e) {
+  const n = t[q];
+  return (n ? ce(n) : t)[e];
+}
+function Ln(t, e, n) {
+  const s = rn(e, n);
+  return s ? Te in s ? s[Te] : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    s.get?.call(t.draft_)
+  ) : void 0;
+}
+function rn(t, e) {
+  if (!(e in t))
+    return;
+  let n = be(t);
+  for (; n; ) {
+    const s = Object.getOwnPropertyDescriptor(n, e);
+    if (s)
+      return s;
+    n = be(n);
+  }
+}
+function ct(t) {
+  t.modified_ || (t.modified_ = !0, t.parent_ && ct(t.parent_));
+}
+function je(t) {
+  t.copy_ || (t.assigned_ = /* @__PURE__ */ new Map(), t.copy_ = rt(
+    t.base_,
+    t.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var $n = class {
+  constructor(t) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !1, this.produce = (e, n, s) => {
+      if (he(e) && !he(n)) {
+        const i = n;
+        n = e;
+        const o = this;
+        return function(l = i, ...d) {
+          return o.produce(l, (f) => n.call(this, f, ...d));
+        };
+      }
+      he(n) || Q(6), s !== void 0 && !he(s) && Q(7);
+      let r;
+      if (le(e)) {
+        const i = Rt(this), o = lt(i, e, void 0);
+        let a = !0;
+        try {
+          r = n(o), a = !1;
+        } finally {
+          a ? ot(i) : at(i);
+        }
+        return Ot(i, s), Nt(r, i);
+      } else if (!e || !pt(e)) {
+        if (r = n(e), r === void 0 && (r = e), r === Jt && (r = void 0), this.autoFreeze_ && gt(r, !0), s) {
+          const i = [], o = [];
+          we(it).generateReplacementPatches_(e, r, {
+            patches_: i,
+            inversePatches_: o
+          }), s(i, o);
+        }
+        return r;
+      } else
+        Q(1, e);
+    }, this.produceWithPatches = (e, n) => {
+      if (he(e))
+        return (o, ...a) => this.produceWithPatches(o, (l) => e(l, ...a));
+      let s, r;
+      return [this.produce(e, n, (o, a) => {
+        s = o, r = a;
+      }), s, r];
+    }, Ze(t?.autoFreeze) && this.setAutoFreeze(t.autoFreeze), Ze(t?.useStrictShallowCopy) && this.setUseStrictShallowCopy(t.useStrictShallowCopy), Ze(t?.useStrictIteration) && this.setUseStrictIteration(t.useStrictIteration);
+  }
+  createDraft(t) {
+    le(t) || Q(8), fe(t) && (t = Hn(t));
+    const e = Rt(this), n = lt(e, t, void 0);
+    return n[q].isManual_ = !0, at(e), n;
+  }
+  finishDraft(t, e) {
+    const n = t && t[q];
+    (!n || !n.isManual_) && Q(9);
+    const { scope_: s } = n;
+    return Ot(s, e), Nt(void 0, s);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(t) {
+    this.autoFreeze_ = t;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(t) {
+    this.useStrictShallowCopy_ = t;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(t) {
+    this.useStrictIteration_ = t;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(t, e) {
+    let n;
+    for (n = e.length - 1; n >= 0; n--) {
+      const r = e[n];
+      if (r.path.length === 0 && r.op === "replace") {
+        t = r.value;
+        break;
+      }
+    }
+    n > -1 && (e = e.slice(n + 1));
+    const s = we(it).applyPatches_;
+    return fe(t) ? s(t, e) : this.produce(
+      t,
+      (r) => s(r, e)
+    );
+  }
+};
+function lt(t, e, n, s) {
+  const [r, i] = We(e) ? we(Ye).proxyMap_(e, n) : Ke(e) ? we(Ye).proxySet_(e, n) : zn(e, n);
+  return (n?.scope_ ?? en()).drafts_.push(r), i.callbacks_ = n?.callbacks_ ?? [], i.key_ = s, n && s !== void 0 ? Mn(n, i, s) : i.callbacks_.push(function(l) {
+    l.mapSetPlugin_?.fixSetContents(i);
+    const { patchPlugin_: d } = l;
+    i.modified_ && d && d.generatePatches_(i, [], l);
+  }), r;
+}
+function Hn(t) {
+  return fe(t) || Q(10, t), on(t);
+}
+function on(t) {
+  if (!le(t) || Ge(t))
+    return t;
+  const e = t[q];
+  let n, s = !0;
+  if (e) {
+    if (!e.modified_)
+      return e.base_;
+    e.finalized_ = !0, n = rt(t, e.scope_.immer_.useStrictShallowCopy_), s = e.scope_.immer_.shouldUseStrictIteration();
+  } else
+    n = rt(t, !0);
+  return ke(
+    n,
+    (r, i) => {
+      Ve(n, r, on(i));
+    },
+    s
+  ), e && (e.finalized_ = !1), n;
+}
+var Vn = new $n(), Yn = Vn.produce;
+const Fn = (t) => (e, n, s) => (s.setState = (r, i, ...o) => {
+  const a = typeof r == "function" ? Yn(r) : r;
+  return e(a, i, ...o);
+}, t(s.setState, n, s)), Un = Fn, Bn = {
+  snapping: !0,
+  snapGuide: !0,
+  rotation: !0,
+  rotationSpeed: 2,
+  rotationSnap: 5,
+  // Default 15 degree snap
+  zoom: !0,
+  pan: !0,
+  viewOnly: !1,
+  minZoom: 0.1,
+  maxZoom: 5,
+  showGrid: !0,
+  gridSize: 20,
+  gridColor: "#ddd"
+}, Xn = (t = [], e = [], n = {}) => En(
+  Un((s) => ({
+    nodes: t.reduce((r, i) => ({ ...r, [i.id]: i }), {}),
+    edges: e.reduce((r, i) => ({ ...r, [i.id]: i }), {}),
+    selectedIds: [],
+    camera: { x: 0, y: 0, zoom: 1 },
+    dimensions: { width: 0, height: 0 },
+    // Init default
+    config: { ...Bn, ...n },
+    // --- Connection State ---
+    connectionState: { nodeId: null, handleId: null, handleType: null, position: null, isValid: !1 },
+    startConnection: (r, i, o, a) => s((l) => {
+      l.connectionState = { nodeId: r, handleId: i, handleType: o, position: a, isValid: !0 };
+    }),
+    updateConnection: (r) => s((i) => {
+      i.connectionState.nodeId && (i.connectionState.position = r);
+    }),
+    endConnection: () => s((r) => {
+      r.connectionState = { nodeId: null, handleId: null, handleType: null, position: null, isValid: !1 };
+    }),
+    setCamera: (r) => s((i) => {
+      Object.assign(i.camera, r);
+    }),
+    panCamera: (r, i) => s((o) => {
+      o.camera.x += r, o.camera.y += i;
+    }),
+    zoomCamera: (r, i, o) => s((a) => {
+      const { minZoom: l = 0.1, maxZoom: d = 5 } = a.config, f = Math.min(Math.max(a.camera.zoom * r, l), d), v = (i - a.camera.x) / a.camera.zoom, m = (o - a.camera.y) / a.camera.zoom;
+      a.camera.x = i - v * f, a.camera.y = o - m * f, a.camera.zoom = f;
+    }),
+    setDimensions: (r, i) => s((o) => {
+      o.dimensions = { width: r, height: i };
+    }),
+    // --- Nodes ---
+    setNodes: (r) => s((i) => {
+      i.nodes = r.reduce((o, a) => ({ ...o, [a.id]: a }), {});
+    }),
+    addNode: (r) => s((i) => {
+      i.nodes[r.id] = r;
+    }),
+    updateNode: (r, i) => s((o) => {
+      o.nodes[r] && Object.assign(o.nodes[r], i);
+    }),
+    registerHandle: (r, i, o) => s((a) => {
+      const l = a.nodes[r];
+      l && (l.handles || (l.handles = {}), l.handles[i] = { id: i, ...o });
+    }),
+    removeNode: (r) => s((i) => {
+      delete i.nodes[r], Object.keys(i.edges).forEach((o) => {
+        const a = i.edges[o];
+        (a.source === r || a.target === r) && delete i.edges[o];
+      }), i.selectedIds = i.selectedIds.filter((o) => o !== r);
+    }),
+    // --- Edges ---
+    setEdges: (r) => s((i) => {
+      i.edges = r.reduce((o, a) => ({ ...o, [a.id]: a }), {});
+    }),
+    addEdge: (r) => s((i) => {
+      Object.values(i.edges).some(
+        (a) => a.source === r.source && a.target === r.target && a.sourceHandle === r.sourceHandle && a.targetHandle === r.targetHandle
+      ) || (i.edges[r.id] = r);
+    }),
+    removeEdge: (r) => s((i) => {
+      delete i.edges[r];
+    }),
+    selectNode: (r) => s((i) => {
+      i.selectedIds = r ? [r] : [];
+    }),
+    resizeNode: (r, i, o, a, l) => s((d) => {
+      d.nodes[r] && (d.nodes[r].x = i, d.nodes[r].y = o, d.nodes[r].width = a, d.nodes[r].height = l);
+    }),
+    rotateNode: (r, i) => s((o) => {
+      o.nodes[r] && (o.nodes[r].rotation = i);
+    }),
+    deleteSelected: () => s((r) => {
+      r.selectedIds.forEach((i) => {
+        r.nodes[i] ? (delete r.nodes[i], Object.keys(r.edges).forEach((o) => {
+          const a = r.edges[o];
+          (a.source === i || a.target === i) && delete r.edges[o];
+        })) : r.edges[i] && delete r.edges[i];
+      }), r.selectedIds = [];
+    }),
+    selectAll: () => s((r) => {
+      r.selectedIds = Object.keys(r.nodes);
+    }),
+    deselectAll: () => s((r) => {
+      r.selectedIds = [];
+    }),
+    duplicateSelected: () => s((r) => {
+      const i = [];
+      r.selectedIds.forEach((o) => {
+        const a = r.nodes[o];
+        if (a) {
+          const l = `node-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`, d = {
+            ...a,
+            id: l,
+            x: a.x + 20,
+            y: a.y + 20
+          };
+          r.nodes[l] = d, i.push(d);
+        }
+      }), r.selectedIds = i.map((o) => o.id);
+    }),
+    nudgeSelected: (r, i) => s((o) => {
+      o.selectedIds.forEach((a) => {
+        const l = o.nodes[a];
+        l && (l.x += r, l.y += i);
+      });
+    }),
+    setConfig: (r) => s((i) => {
+      i.config = { ...i.config, ...r };
+    })
+  }))
+), vt = qt(null), gr = ({ children: t, initialNodes: e = [], initialEdges: n = [], nodes: s, config: r = {}, className: i = "", style: o, onChange: a }) => {
+  const l = ve(null);
+  return l.current || (l.current = Xn(e, n, r)), ie(() => {
+    s && l.current && l.current.getState().setNodes(s);
+  }, [s]), ie(() => {
+    if (!a || !l.current) return;
+    const d = l.current.subscribe((f) => {
+      a(f);
+    });
+    return () => d();
+  }, [a]), ie(() => {
+    l.current && l.current.getState().setConfig(r);
+  }, [r]), /* @__PURE__ */ y.jsx(vt.Provider, { value: l.current, children: /* @__PURE__ */ y.jsx("div", { className: `ce-editor ${i}`, style: o, children: t }) });
+}, C = (t) => {
+  const e = ht(vt);
+  if (!e) throw new Error("useEditor must be used within Editor");
+  return Tn(e, t);
+}, bt = () => {
+  const t = ht(vt);
+  if (!t) throw new Error("useEditor must be used within Editor");
+  return t;
+}, an = qt(null), Wn = ({ id: t, children: e }) => /* @__PURE__ */ y.jsx(an.Provider, { value: t, children: e }), Kn = () => {
+  const t = ht(an);
+  return t || null;
+}, Fe = ({ type: t, id: e = "default", position: n = "top", className: s = "", style: r, ...i }) => {
+  const o = Kn(), a = C((w) => w.startConnection), l = C((w) => w.camera), d = C((w) => w.registerHandle), f = bt(), v = re.useRef(null);
+  ie(() => {
+    if (!o || !v.current) return;
+    const w = () => {
+      const c = document.getElementById(o);
+      if (!c || !v.current) return;
+      const g = c.getBoundingClientRect(), p = v.current.getBoundingClientRect(), b = f.getState().camera.zoom, _ = (p.left + p.width / 2 - g.left) / b, k = (p.top + p.height / 2 - g.top) / b;
+      d(o, e, {
+        type: t,
+        position: n,
+        x: _,
+        y: k,
+        width: p.width / b,
+        height: p.height / b
+      });
+    };
+    w();
+    const O = document.getElementById(o);
+    if (!O) return;
+    const R = new ResizeObserver(() => {
+      requestAnimationFrame(w);
+    });
+    return R.observe(O), () => R.disconnect();
+  }, [o, e, t, n, d]);
+  const m = (w) => {
+    if (!o) return;
+    w.stopPropagation();
+    const O = document.querySelector(".ce-editor__viewport")?.getBoundingClientRect();
+    if (!O) return;
+    const R = (w.clientX - O.left - l.x) / l.zoom, c = (w.clientY - O.top - l.y) / l.zoom;
+    a(o, e, t, { x: R, y: c });
+  };
+  return /* @__PURE__ */ y.jsx(
+    "div",
+    {
+      ref: v,
+      "data-handle-type": t,
+      "data-handle-id": e,
+      onPointerDown: m,
+      className: `ce-handle ce-handle--${n} ${s}`,
+      style: r,
+      ...i
+    }
+  );
+}, ut = ({ data: t, ...e }) => /* @__PURE__ */ y.jsxs("div", { className: "ce-node-default", ...e, style: e.style, children: [
+  /* @__PURE__ */ y.jsx(Fe, { type: "target", position: "left", id: "input" }),
+  /* @__PURE__ */ y.jsx("div", { className: "ce-node-content", children: t.label || "Default Node" }),
+  /* @__PURE__ */ y.jsx(Fe, { type: "source", position: "right", id: "output" })
+] }), Gn = ({ data: t, ...e }) => /* @__PURE__ */ y.jsxs("div", { className: "ce-node-input", ...e, style: e.style, children: [
+  /* @__PURE__ */ y.jsx("div", { className: "ce-node-content", children: t.label || "Input Node" }),
+  /* @__PURE__ */ y.jsx(Fe, { type: "source", position: "right", id: "output" })
+] }), qn = ({ data: t, ...e }) => /* @__PURE__ */ y.jsxs("div", { className: "ce-node-output", ...e, style: e.style, children: [
+  /* @__PURE__ */ y.jsx(Fe, { type: "target", position: "left", id: "input" }),
+  /* @__PURE__ */ y.jsx("div", { className: "ce-node-content", children: t.label || "Output Node" })
+] });
+function Jn(t, e, n) {
+  return Math.max(e, Math.min(t, n));
+}
+const $ = {
+  toVector(t, e) {
+    return t === void 0 && (t = e), Array.isArray(t) ? t : [t, t];
+  },
+  add(t, e) {
+    return [t[0] + e[0], t[1] + e[1]];
+  },
+  sub(t, e) {
+    return [t[0] - e[0], t[1] - e[1]];
+  },
+  addTo(t, e) {
+    t[0] += e[0], t[1] += e[1];
+  },
+  subTo(t, e) {
+    t[0] -= e[0], t[1] -= e[1];
+  }
+};
+function Ct(t, e, n) {
+  return e === 0 || Math.abs(e) === 1 / 0 ? Math.pow(t, n * 5) : t * e * n / (e + n * t);
+}
+function Mt(t, e, n, s = 0.15) {
+  return s === 0 ? Jn(t, e, n) : t < e ? -Ct(e - t, n - e, s) + e : t > n ? +Ct(t - n, n - e, s) + n : t;
+}
+function Zn(t, [e, n], [s, r]) {
+  const [[i, o], [a, l]] = t;
+  return [Mt(e, i, o, s), Mt(n, a, l, r)];
+}
+function Qn(t, e) {
+  if (typeof t != "object" || t === null) return t;
+  var n = t[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var s = n.call(t, e);
+    if (typeof s != "object") return s;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(t);
+}
+function es(t) {
+  var e = Qn(t, "string");
+  return typeof e == "symbol" ? e : String(e);
+}
+function X(t, e, n) {
+  return e = es(e), e in t ? Object.defineProperty(t, e, {
+    value: n,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = n, t;
+}
+function jt(t, e) {
+  var n = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var s = Object.getOwnPropertySymbols(t);
+    e && (s = s.filter(function(r) {
+      return Object.getOwnPropertyDescriptor(t, r).enumerable;
+    })), n.push.apply(n, s);
+  }
+  return n;
+}
+function Y(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var n = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? jt(Object(n), !0).forEach(function(s) {
+      X(t, s, n[s]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(n)) : jt(Object(n)).forEach(function(s) {
+      Object.defineProperty(t, s, Object.getOwnPropertyDescriptor(n, s));
+    });
+  }
+  return t;
+}
+const cn = {
+  pointer: {
+    start: "down",
+    change: "move",
+    end: "up"
+  },
+  mouse: {
+    start: "down",
+    change: "move",
+    end: "up"
+  },
+  touch: {
+    start: "start",
+    change: "move",
+    end: "end"
+  },
+  gesture: {
+    start: "start",
+    change: "change",
+    end: "end"
+  }
+};
+function zt(t) {
+  return t ? t[0].toUpperCase() + t.slice(1) : "";
+}
+const ts = ["enter", "leave"];
+function ns(t = !1, e) {
+  return t && !ts.includes(e);
+}
+function ss(t, e = "", n = !1) {
+  const s = cn[t], r = s && s[e] || e;
+  return "on" + zt(t) + zt(r) + (ns(n, r) ? "Capture" : "");
+}
+const rs = ["gotpointercapture", "lostpointercapture"];
+function is(t) {
+  let e = t.substring(2).toLowerCase();
+  const n = !!~e.indexOf("passive");
+  n && (e = e.replace("passive", ""));
+  const s = rs.includes(e) ? "capturecapture" : "capture", r = !!~e.indexOf(s);
+  return r && (e = e.replace("capture", "")), {
+    device: e,
+    capture: r,
+    passive: n
+  };
+}
+function os(t, e = "") {
+  const n = cn[t], s = n && n[e] || e;
+  return t + s;
+}
+function Je(t) {
+  return "touches" in t;
+}
+function ln(t) {
+  return Je(t) ? "touch" : "pointerType" in t ? t.pointerType : "mouse";
+}
+function as(t) {
+  return Array.from(t.touches).filter((e) => {
+    var n, s;
+    return e.target === t.currentTarget || ((n = t.currentTarget) === null || n === void 0 || (s = n.contains) === null || s === void 0 ? void 0 : s.call(n, e.target));
+  });
+}
+function cs(t) {
+  return t.type === "touchend" || t.type === "touchcancel" ? t.changedTouches : t.targetTouches;
+}
+function un(t) {
+  return Je(t) ? cs(t)[0] : t;
+}
+function dt(t, e) {
+  try {
+    const n = e.clientX - t.clientX, s = e.clientY - t.clientY, r = (e.clientX + t.clientX) / 2, i = (e.clientY + t.clientY) / 2, o = Math.hypot(n, s);
+    return {
+      angle: -(Math.atan2(n, s) * 180) / Math.PI,
+      distance: o,
+      origin: [r, i]
+    };
+  } catch {
+  }
+  return null;
+}
+function ls(t) {
+  return as(t).map((e) => e.identifier);
+}
+function Lt(t, e) {
+  const [n, s] = Array.from(t.touches).filter((r) => e.includes(r.identifier));
+  return dt(n, s);
+}
+function et(t) {
+  const e = un(t);
+  return Je(t) ? e.identifier : e.pointerId;
+}
+function xe(t) {
+  const e = un(t);
+  return [e.clientX, e.clientY];
+}
+const $t = 40, Ht = 800;
+function dn(t) {
+  let {
+    deltaX: e,
+    deltaY: n,
+    deltaMode: s
+  } = t;
+  return s === 1 ? (e *= $t, n *= $t) : s === 2 && (e *= Ht, n *= Ht), [e, n];
+}
+function us(t) {
+  var e, n;
+  const {
+    scrollX: s,
+    scrollY: r,
+    scrollLeft: i,
+    scrollTop: o
+  } = t.currentTarget;
+  return [(e = s ?? i) !== null && e !== void 0 ? e : 0, (n = r ?? o) !== null && n !== void 0 ? n : 0];
+}
+function ds(t) {
+  const e = {};
+  if ("buttons" in t && (e.buttons = t.buttons), "shiftKey" in t) {
+    const {
+      shiftKey: n,
+      altKey: s,
+      metaKey: r,
+      ctrlKey: i
+    } = t;
+    Object.assign(e, {
+      shiftKey: n,
+      altKey: s,
+      metaKey: r,
+      ctrlKey: i
+    });
+  }
+  return e;
+}
+function Ue(t, ...e) {
+  return typeof t == "function" ? t(...e) : t;
+}
+function fs() {
+}
+function hs(...t) {
+  return t.length === 0 ? fs : t.length === 1 ? t[0] : function() {
+    let e;
+    for (const n of t)
+      e = n.apply(this, arguments) || e;
+    return e;
+  };
+}
+function Vt(t, e) {
+  return Object.assign({}, e, t || {});
+}
+const ps = 32;
+class fn {
+  constructor(e, n, s) {
+    this.ctrl = e, this.args = n, this.key = s, this.state || (this.state = {}, this.computeValues([0, 0]), this.computeInitial(), this.init && this.init(), this.reset());
+  }
+  get state() {
+    return this.ctrl.state[this.key];
+  }
+  set state(e) {
+    this.ctrl.state[this.key] = e;
+  }
+  get shared() {
+    return this.ctrl.state.shared;
+  }
+  get eventStore() {
+    return this.ctrl.gestureEventStores[this.key];
+  }
+  get timeoutStore() {
+    return this.ctrl.gestureTimeoutStores[this.key];
+  }
+  get config() {
+    return this.ctrl.config[this.key];
+  }
+  get sharedConfig() {
+    return this.ctrl.config.shared;
+  }
+  get handler() {
+    return this.ctrl.handlers[this.key];
+  }
+  reset() {
+    const {
+      state: e,
+      shared: n,
+      ingKey: s,
+      args: r
+    } = this;
+    n[s] = e._active = e.active = e._blocked = e._force = !1, e._step = [!1, !1], e.intentional = !1, e._movement = [0, 0], e._distance = [0, 0], e._direction = [0, 0], e._delta = [0, 0], e._bounds = [[-1 / 0, 1 / 0], [-1 / 0, 1 / 0]], e.args = r, e.axis = void 0, e.memo = void 0, e.elapsedTime = e.timeDelta = 0, e.direction = [0, 0], e.distance = [0, 0], e.overflow = [0, 0], e._movementBound = [!1, !1], e.velocity = [0, 0], e.movement = [0, 0], e.delta = [0, 0], e.timeStamp = 0;
+  }
+  start(e) {
+    const n = this.state, s = this.config;
+    n._active || (this.reset(), this.computeInitial(), n._active = !0, n.target = e.target, n.currentTarget = e.currentTarget, n.lastOffset = s.from ? Ue(s.from, n) : n.offset, n.offset = n.lastOffset, n.startTime = n.timeStamp = e.timeStamp);
+  }
+  computeValues(e) {
+    const n = this.state;
+    n._values = e, n.values = this.config.transform(e);
+  }
+  computeInitial() {
+    const e = this.state;
+    e._initial = e._values, e.initial = e.values;
+  }
+  compute(e) {
+    const {
+      state: n,
+      config: s,
+      shared: r
+    } = this;
+    n.args = this.args;
+    let i = 0;
+    if (e && (n.event = e, s.preventDefault && e.cancelable && n.event.preventDefault(), n.type = e.type, r.touches = this.ctrl.pointerIds.size || this.ctrl.touchIds.size, r.locked = !!document.pointerLockElement, Object.assign(r, ds(e)), r.down = r.pressed = r.buttons % 2 === 1 || r.touches > 0, i = e.timeStamp - n.timeStamp, n.timeStamp = e.timeStamp, n.elapsedTime = n.timeStamp - n.startTime), n._active) {
+      const h = n._delta.map(Math.abs);
+      $.addTo(n._distance, h);
+    }
+    this.axisIntent && this.axisIntent(e);
+    const [o, a] = n._movement, [l, d] = s.threshold, {
+      _step: f,
+      values: v
+    } = n;
+    if (s.hasCustomTransform ? (f[0] === !1 && (f[0] = Math.abs(o) >= l && v[0]), f[1] === !1 && (f[1] = Math.abs(a) >= d && v[1])) : (f[0] === !1 && (f[0] = Math.abs(o) >= l && Math.sign(o) * l), f[1] === !1 && (f[1] = Math.abs(a) >= d && Math.sign(a) * d)), n.intentional = f[0] !== !1 || f[1] !== !1, !n.intentional) return;
+    const m = [0, 0];
+    if (s.hasCustomTransform) {
+      const [h, D] = v;
+      m[0] = f[0] !== !1 ? h - f[0] : 0, m[1] = f[1] !== !1 ? D - f[1] : 0;
+    } else
+      m[0] = f[0] !== !1 ? o - f[0] : 0, m[1] = f[1] !== !1 ? a - f[1] : 0;
+    this.restrictToAxis && !n._blocked && this.restrictToAxis(m);
+    const w = n.offset, O = n._active && !n._blocked || n.active;
+    O && (n.first = n._active && !n.active, n.last = !n._active && n.active, n.active = r[this.ingKey] = n._active, e && (n.first && ("bounds" in s && (n._bounds = Ue(s.bounds, n)), this.setup && this.setup()), n.movement = m, this.computeOffset()));
+    const [R, c] = n.offset, [[g, p], [b, _]] = n._bounds;
+    n.overflow = [R < g ? -1 : R > p ? 1 : 0, c < b ? -1 : c > _ ? 1 : 0], n._movementBound[0] = n.overflow[0] ? n._movementBound[0] === !1 ? n._movement[0] : n._movementBound[0] : !1, n._movementBound[1] = n.overflow[1] ? n._movementBound[1] === !1 ? n._movement[1] : n._movementBound[1] : !1;
+    const k = n._active ? s.rubberband || [0, 0] : [0, 0];
+    if (n.offset = Zn(n._bounds, n.offset, k), n.delta = $.sub(n.offset, w), this.computeMovement(), O && (!n.last || i > ps)) {
+      n.delta = $.sub(n.offset, w);
+      const h = n.delta.map(Math.abs);
+      $.addTo(n.distance, h), n.direction = n.delta.map(Math.sign), n._direction = n._delta.map(Math.sign), !n.first && i > 0 && (n.velocity = [h[0] / i, h[1] / i], n.timeDelta = i);
+    }
+  }
+  emit() {
+    const e = this.state, n = this.shared, s = this.config;
+    if (e._active || this.clean(), (e._blocked || !e.intentional) && !e._force && !s.triggerAllEvents) return;
+    const r = this.handler(Y(Y(Y({}, n), e), {}, {
+      [this.aliasKey]: e.values
+    }));
+    r !== void 0 && (e.memo = r);
+  }
+  clean() {
+    this.eventStore.clean(), this.timeoutStore.clean();
+  }
+}
+function ms([t, e], n) {
+  const s = Math.abs(t), r = Math.abs(e);
+  if (s > r && s > n)
+    return "x";
+  if (r > s && r > n)
+    return "y";
+}
+class Oe extends fn {
+  constructor(...e) {
+    super(...e), X(this, "aliasKey", "xy");
+  }
+  reset() {
+    super.reset(), this.state.axis = void 0;
+  }
+  init() {
+    this.state.offset = [0, 0], this.state.lastOffset = [0, 0];
+  }
+  computeOffset() {
+    this.state.offset = $.add(this.state.lastOffset, this.state.movement);
+  }
+  computeMovement() {
+    this.state.movement = $.sub(this.state.offset, this.state.lastOffset);
+  }
+  axisIntent(e) {
+    const n = this.state, s = this.config;
+    if (!n.axis && e) {
+      const r = typeof s.axisThreshold == "object" ? s.axisThreshold[ln(e)] : s.axisThreshold;
+      n.axis = ms(n._movement, r);
+    }
+    n._blocked = (s.lockDirection || !!s.axis) && !n.axis || !!s.axis && s.axis !== n.axis;
+  }
+  restrictToAxis(e) {
+    if (this.config.axis || this.config.lockDirection)
+      switch (this.state.axis) {
+        case "x":
+          e[1] = 0;
+          break;
+        case "y":
+          e[0] = 0;
+          break;
+      }
+  }
+}
+const Yt = (t) => t, Ft = 0.15, wt = {
+  enabled(t = !0) {
+    return t;
+  },
+  eventOptions(t, e, n) {
+    return Y(Y({}, n.shared.eventOptions), t);
+  },
+  preventDefault(t = !1) {
+    return t;
+  },
+  triggerAllEvents(t = !1) {
+    return t;
+  },
+  rubberband(t = 0) {
+    switch (t) {
+      case !0:
+        return [Ft, Ft];
+      case !1:
+        return [0, 0];
+      default:
+        return $.toVector(t);
+    }
+  },
+  from(t) {
+    if (typeof t == "function") return t;
+    if (t != null) return $.toVector(t);
+  },
+  transform(t, e, n) {
+    const s = t || n.shared.transform;
+    if (this.hasCustomTransform = !!s, process.env.NODE_ENV === "development") {
+      const r = s || Yt;
+      return (i) => {
+        const o = r(i);
+        return (!isFinite(o[0]) || !isFinite(o[1])) && console.warn(`[@use-gesture]: config.transform() must produce a valid result, but it was: [${o[0]},${[1]}]`), o;
+      };
+    }
+    return s || Yt;
+  },
+  threshold(t) {
+    return $.toVector(t, 0);
+  }
+};
+process.env.NODE_ENV === "development" && Object.assign(wt, {
+  domTarget(t) {
+    if (t !== void 0)
+      throw Error("[@use-gesture]: `domTarget` option has been renamed to `target`.");
+    return NaN;
+  },
+  lockDirection(t) {
+    if (t !== void 0)
+      throw Error("[@use-gesture]: `lockDirection` option has been merged with `axis`. Use it as in `{ axis: 'lock' }`");
+    return NaN;
+  },
+  initial(t) {
+    if (t !== void 0)
+      throw Error("[@use-gesture]: `initial` option has been renamed to `from`.");
+    return NaN;
+  }
+});
+const gs = 0, pe = Y(Y({}, wt), {}, {
+  axis(t, e, {
+    axis: n
+  }) {
+    if (this.lockDirection = n === "lock", !this.lockDirection) return n;
+  },
+  axisThreshold(t = gs) {
+    return t;
+  },
+  bounds(t = {}) {
+    if (typeof t == "function")
+      return (i) => pe.bounds(t(i));
+    if ("current" in t)
+      return () => t.current;
+    if (typeof HTMLElement == "function" && t instanceof HTMLElement)
+      return t;
+    const {
+      left: e = -1 / 0,
+      right: n = 1 / 0,
+      top: s = -1 / 0,
+      bottom: r = 1 / 0
+    } = t;
+    return [[e, n], [s, r]];
+  }
+}), Ut = {
+  ArrowRight: (t, e = 1) => [t * e, 0],
+  ArrowLeft: (t, e = 1) => [-1 * t * e, 0],
+  ArrowUp: (t, e = 1) => [0, -1 * t * e],
+  ArrowDown: (t, e = 1) => [0, t * e]
+};
+class ys extends Oe {
+  constructor(...e) {
+    super(...e), X(this, "ingKey", "dragging");
+  }
+  reset() {
+    super.reset();
+    const e = this.state;
+    e._pointerId = void 0, e._pointerActive = !1, e._keyboardActive = !1, e._preventScroll = !1, e._delayed = !1, e.swipe = [0, 0], e.tap = !1, e.canceled = !1, e.cancel = this.cancel.bind(this);
+  }
+  setup() {
+    const e = this.state;
+    if (e._bounds instanceof HTMLElement) {
+      const n = e._bounds.getBoundingClientRect(), s = e.currentTarget.getBoundingClientRect(), r = {
+        left: n.left - s.left + e.offset[0],
+        right: n.right - s.right + e.offset[0],
+        top: n.top - s.top + e.offset[1],
+        bottom: n.bottom - s.bottom + e.offset[1]
+      };
+      e._bounds = pe.bounds(r);
+    }
+  }
+  cancel() {
+    const e = this.state;
+    e.canceled || (e.canceled = !0, e._active = !1, setTimeout(() => {
+      this.compute(), this.emit();
+    }, 0));
+  }
+  setActive() {
+    this.state._active = this.state._pointerActive || this.state._keyboardActive;
+  }
+  clean() {
+    this.pointerClean(), this.state._pointerActive = !1, this.state._keyboardActive = !1, super.clean();
+  }
+  pointerDown(e) {
+    const n = this.config, s = this.state;
+    if (e.buttons != null && (Array.isArray(n.pointerButtons) ? !n.pointerButtons.includes(e.buttons) : n.pointerButtons !== -1 && n.pointerButtons !== e.buttons)) return;
+    const r = this.ctrl.setEventIds(e);
+    n.pointerCapture && e.target.setPointerCapture(e.pointerId), !(r && r.size > 1 && s._pointerActive) && (this.start(e), this.setupPointer(e), s._pointerId = et(e), s._pointerActive = !0, this.computeValues(xe(e)), this.computeInitial(), n.preventScrollAxis && ln(e) !== "mouse" ? (s._active = !1, this.setupScrollPrevention(e)) : n.delay > 0 ? (this.setupDelayTrigger(e), n.triggerAllEvents && (this.compute(e), this.emit())) : this.startPointerDrag(e));
+  }
+  startPointerDrag(e) {
+    const n = this.state;
+    n._active = !0, n._preventScroll = !0, n._delayed = !1, this.compute(e), this.emit();
+  }
+  pointerMove(e) {
+    const n = this.state, s = this.config;
+    if (!n._pointerActive) return;
+    const r = et(e);
+    if (n._pointerId !== void 0 && r !== n._pointerId) return;
+    const i = xe(e);
+    if (document.pointerLockElement === e.target ? n._delta = [e.movementX, e.movementY] : (n._delta = $.sub(i, n._values), this.computeValues(i)), $.addTo(n._movement, n._delta), this.compute(e), n._delayed && n.intentional) {
+      this.timeoutStore.remove("dragDelay"), n.active = !1, this.startPointerDrag(e);
+      return;
+    }
+    if (s.preventScrollAxis && !n._preventScroll)
+      if (n.axis)
+        if (n.axis === s.preventScrollAxis || s.preventScrollAxis === "xy") {
+          n._active = !1, this.clean();
+          return;
+        } else {
+          this.timeoutStore.remove("startPointerDrag"), this.startPointerDrag(e);
+          return;
+        }
+      else
+        return;
+    this.emit();
+  }
+  pointerUp(e) {
+    this.ctrl.setEventIds(e);
+    try {
+      this.config.pointerCapture && e.target.hasPointerCapture(e.pointerId) && e.target.releasePointerCapture(e.pointerId);
+    } catch {
+      process.env.NODE_ENV === "development" && console.warn("[@use-gesture]: If you see this message, it's likely that you're using an outdated version of `@react-three/fiber`. \n\nPlease upgrade to the latest version.");
+    }
+    const n = this.state, s = this.config;
+    if (!n._active || !n._pointerActive) return;
+    const r = et(e);
+    if (n._pointerId !== void 0 && r !== n._pointerId) return;
+    this.state._pointerActive = !1, this.setActive(), this.compute(e);
+    const [i, o] = n._distance;
+    if (n.tap = i <= s.tapsThreshold && o <= s.tapsThreshold, n.tap && s.filterTaps)
+      n._force = !0;
+    else {
+      const [a, l] = n._delta, [d, f] = n._movement, [v, m] = s.swipe.velocity, [w, O] = s.swipe.distance, R = s.swipe.duration;
+      if (n.elapsedTime < R) {
+        const c = Math.abs(a / n.timeDelta), g = Math.abs(l / n.timeDelta);
+        c > v && Math.abs(d) > w && (n.swipe[0] = Math.sign(a)), g > m && Math.abs(f) > O && (n.swipe[1] = Math.sign(l));
+      }
+    }
+    this.emit();
+  }
+  pointerClick(e) {
+    !this.state.tap && e.detail > 0 && (e.preventDefault(), e.stopPropagation());
+  }
+  setupPointer(e) {
+    const n = this.config, s = n.device;
+    if (process.env.NODE_ENV === "development")
+      try {
+        if (s === "pointer" && n.preventScrollDelay === void 0) {
+          const r = "uv" in e ? e.sourceEvent.currentTarget : e.currentTarget;
+          window.getComputedStyle(r).touchAction === "auto" && console.warn("[@use-gesture]: The drag target has its `touch-action` style property set to `auto`. It is recommended to add `touch-action: 'none'` so that the drag gesture behaves correctly on touch-enabled devices. For more information read this: https://use-gesture.netlify.app/docs/extras/#touch-action.\n\nThis message will only show in development mode. It won't appear in production. If this is intended, you can ignore it.", r);
+        }
+      } catch {
+      }
+    n.pointerLock && e.currentTarget.requestPointerLock(), n.pointerCapture || (this.eventStore.add(this.sharedConfig.window, s, "change", this.pointerMove.bind(this)), this.eventStore.add(this.sharedConfig.window, s, "end", this.pointerUp.bind(this)), this.eventStore.add(this.sharedConfig.window, s, "cancel", this.pointerUp.bind(this)));
+  }
+  pointerClean() {
+    this.config.pointerLock && document.pointerLockElement === this.state.currentTarget && document.exitPointerLock();
+  }
+  preventScroll(e) {
+    this.state._preventScroll && e.cancelable && e.preventDefault();
+  }
+  setupScrollPrevention(e) {
+    this.state._preventScroll = !1, _s(e);
+    const n = this.eventStore.add(this.sharedConfig.window, "touch", "change", this.preventScroll.bind(this), {
+      passive: !1
+    });
+    this.eventStore.add(this.sharedConfig.window, "touch", "end", n), this.eventStore.add(this.sharedConfig.window, "touch", "cancel", n), this.timeoutStore.add("startPointerDrag", this.startPointerDrag.bind(this), this.config.preventScrollDelay, e);
+  }
+  setupDelayTrigger(e) {
+    this.state._delayed = !0, this.timeoutStore.add("dragDelay", () => {
+      this.state._step = [0, 0], this.startPointerDrag(e);
+    }, this.config.delay);
+  }
+  keyDown(e) {
+    const n = Ut[e.key];
+    if (n) {
+      const s = this.state, r = e.shiftKey ? 10 : e.altKey ? 0.1 : 1;
+      this.start(e), s._delta = n(this.config.keyboardDisplacement, r), s._keyboardActive = !0, $.addTo(s._movement, s._delta), this.compute(e), this.emit();
+    }
+  }
+  keyUp(e) {
+    e.key in Ut && (this.state._keyboardActive = !1, this.setActive(), this.compute(e), this.emit());
+  }
+  bind(e) {
+    const n = this.config.device;
+    e(n, "start", this.pointerDown.bind(this)), this.config.pointerCapture && (e(n, "change", this.pointerMove.bind(this)), e(n, "end", this.pointerUp.bind(this)), e(n, "cancel", this.pointerUp.bind(this)), e("lostPointerCapture", "", this.pointerUp.bind(this))), this.config.keys && (e("key", "down", this.keyDown.bind(this)), e("key", "up", this.keyUp.bind(this))), this.config.filterTaps && e("click", "", this.pointerClick.bind(this), {
+      capture: !0,
+      passive: !1
+    });
+  }
+}
+function _s(t) {
+  "persist" in t && typeof t.persist == "function" && t.persist();
+}
+const Re = typeof window < "u" && window.document && window.document.createElement;
+function hn() {
+  return Re && "ontouchstart" in window;
+}
+function vs() {
+  return hn() || Re && window.navigator.maxTouchPoints > 1;
+}
+function bs() {
+  return Re && "onpointerdown" in window;
+}
+function ws() {
+  return Re && "exitPointerLock" in window.document;
+}
+function xs() {
+  try {
+    return "constructor" in GestureEvent;
+  } catch {
+    return !1;
+  }
+}
+const ne = {
+  isBrowser: Re,
+  gesture: xs(),
+  touch: hn(),
+  touchscreen: vs(),
+  pointer: bs(),
+  pointerLock: ws()
+}, Es = 250, Ss = 180, Ts = 0.5, Is = 50, Ps = 250, ks = 10, Bt = {
+  mouse: 0,
+  touch: 0,
+  pen: 8
+}, pn = Y(Y({}, pe), {}, {
+  device(t, e, {
+    pointer: {
+      touch: n = !1,
+      lock: s = !1,
+      mouse: r = !1
+    } = {}
+  }) {
+    return this.pointerLock = s && ne.pointerLock, ne.touch && n ? "touch" : this.pointerLock ? "mouse" : ne.pointer && !r ? "pointer" : ne.touch ? "touch" : "mouse";
+  },
+  preventScrollAxis(t, e, {
+    preventScroll: n
+  }) {
+    if (this.preventScrollDelay = typeof n == "number" ? n : n || n === void 0 && t ? Es : void 0, !(!ne.touchscreen || n === !1))
+      return t || (n !== void 0 ? "y" : void 0);
+  },
+  pointerCapture(t, e, {
+    pointer: {
+      capture: n = !0,
+      buttons: s = 1,
+      keys: r = !0
+    } = {}
+  }) {
+    return this.pointerButtons = s, this.keys = r, !this.pointerLock && this.device === "pointer" && n;
+  },
+  threshold(t, e, {
+    filterTaps: n = !1,
+    tapsThreshold: s = 3,
+    axis: r = void 0
+  }) {
+    const i = $.toVector(t, n ? s : r ? 1 : 0);
+    return this.filterTaps = n, this.tapsThreshold = s, i;
+  },
+  swipe({
+    velocity: t = Ts,
+    distance: e = Is,
+    duration: n = Ps
+  } = {}) {
+    return {
+      velocity: this.transform($.toVector(t)),
+      distance: this.transform($.toVector(e)),
+      duration: n
+    };
+  },
+  delay(t = 0) {
+    switch (t) {
+      case !0:
+        return Ss;
+      case !1:
+        return 0;
+      default:
+        return t;
+    }
+  },
+  axisThreshold(t) {
+    return t ? Y(Y({}, Bt), t) : Bt;
+  },
+  keyboardDisplacement(t = ks) {
+    return t;
+  }
+});
+process.env.NODE_ENV === "development" && Object.assign(pn, {
+  useTouch(t) {
+    if (t !== void 0)
+      throw Error("[@use-gesture]: `useTouch` option has been renamed to `pointer.touch`. Use it as in `{ pointer: { touch: true } }`.");
+    return NaN;
+  },
+  experimental_preventWindowScrollY(t) {
+    if (t !== void 0)
+      throw Error("[@use-gesture]: `experimental_preventWindowScrollY` option has been renamed to `preventScroll`.");
+    return NaN;
+  },
+  swipeVelocity(t) {
+    if (t !== void 0)
+      throw Error("[@use-gesture]: `swipeVelocity` option has been renamed to `swipe.velocity`. Use it as in `{ swipe: { velocity: 0.5 } }`.");
+    return NaN;
+  },
+  swipeDistance(t) {
+    if (t !== void 0)
+      throw Error("[@use-gesture]: `swipeDistance` option has been renamed to `swipe.distance`. Use it as in `{ swipe: { distance: 50 } }`.");
+    return NaN;
+  },
+  swipeDuration(t) {
+    if (t !== void 0)
+      throw Error("[@use-gesture]: `swipeDuration` option has been renamed to `swipe.duration`. Use it as in `{ swipe: { duration: 250 } }`.");
+    return NaN;
+  }
+});
+function mn(t) {
+  const [e, n] = t.overflow, [s, r] = t._delta, [i, o] = t._direction;
+  (e < 0 && s > 0 && i < 0 || e > 0 && s < 0 && i > 0) && (t._movement[0] = t._movementBound[0]), (n < 0 && r > 0 && o < 0 || n > 0 && r < 0 && o > 0) && (t._movement[1] = t._movementBound[1]);
+}
+const Ds = 30, Os = 100;
+class Rs extends fn {
+  constructor(...e) {
+    super(...e), X(this, "ingKey", "pinching"), X(this, "aliasKey", "da");
+  }
+  init() {
+    this.state.offset = [1, 0], this.state.lastOffset = [1, 0], this.state._pointerEvents = /* @__PURE__ */ new Map();
+  }
+  reset() {
+    super.reset();
+    const e = this.state;
+    e._touchIds = [], e.canceled = !1, e.cancel = this.cancel.bind(this), e.turns = 0;
+  }
+  computeOffset() {
+    const {
+      type: e,
+      movement: n,
+      lastOffset: s
+    } = this.state;
+    e === "wheel" ? this.state.offset = $.add(n, s) : this.state.offset = [(1 + n[0]) * s[0], n[1] + s[1]];
+  }
+  computeMovement() {
+    const {
+      offset: e,
+      lastOffset: n
+    } = this.state;
+    this.state.movement = [e[0] / n[0], e[1] - n[1]];
+  }
+  axisIntent() {
+    const e = this.state, [n, s] = e._movement;
+    if (!e.axis) {
+      const r = Math.abs(n) * Ds - Math.abs(s);
+      r < 0 ? e.axis = "angle" : r > 0 && (e.axis = "scale");
+    }
+  }
+  restrictToAxis(e) {
+    this.config.lockDirection && (this.state.axis === "scale" ? e[1] = 0 : this.state.axis === "angle" && (e[0] = 0));
+  }
+  cancel() {
+    const e = this.state;
+    e.canceled || setTimeout(() => {
+      e.canceled = !0, e._active = !1, this.compute(), this.emit();
+    }, 0);
+  }
+  touchStart(e) {
+    this.ctrl.setEventIds(e);
+    const n = this.state, s = this.ctrl.touchIds;
+    if (n._active && n._touchIds.every((i) => s.has(i)) || s.size < 2) return;
+    this.start(e), n._touchIds = Array.from(s).slice(0, 2);
+    const r = Lt(e, n._touchIds);
+    r && this.pinchStart(e, r);
+  }
+  pointerStart(e) {
+    if (e.buttons != null && e.buttons % 2 !== 1) return;
+    this.ctrl.setEventIds(e), e.target.setPointerCapture(e.pointerId);
+    const n = this.state, s = n._pointerEvents, r = this.ctrl.pointerIds;
+    if (n._active && Array.from(s.keys()).every((o) => r.has(o)) || (s.size < 2 && s.set(e.pointerId, e), n._pointerEvents.size < 2)) return;
+    this.start(e);
+    const i = dt(...Array.from(s.values()));
+    i && this.pinchStart(e, i);
+  }
+  pinchStart(e, n) {
+    const s = this.state;
+    s.origin = n.origin, this.computeValues([n.distance, n.angle]), this.computeInitial(), this.compute(e), this.emit();
+  }
+  touchMove(e) {
+    if (!this.state._active) return;
+    const n = Lt(e, this.state._touchIds);
+    n && this.pinchMove(e, n);
+  }
+  pointerMove(e) {
+    const n = this.state._pointerEvents;
+    if (n.has(e.pointerId) && n.set(e.pointerId, e), !this.state._active) return;
+    const s = dt(...Array.from(n.values()));
+    s && this.pinchMove(e, s);
+  }
+  pinchMove(e, n) {
+    const s = this.state, r = s._values[1], i = n.angle - r;
+    let o = 0;
+    Math.abs(i) > 270 && (o += Math.sign(i)), this.computeValues([n.distance, n.angle - 360 * o]), s.origin = n.origin, s.turns = o, s._movement = [s._values[0] / s._initial[0] - 1, s._values[1] - s._initial[1]], this.compute(e), this.emit();
+  }
+  touchEnd(e) {
+    this.ctrl.setEventIds(e), this.state._active && this.state._touchIds.some((n) => !this.ctrl.touchIds.has(n)) && (this.state._active = !1, this.compute(e), this.emit());
+  }
+  pointerEnd(e) {
+    const n = this.state;
+    this.ctrl.setEventIds(e);
+    try {
+      e.target.releasePointerCapture(e.pointerId);
+    } catch {
+    }
+    n._pointerEvents.has(e.pointerId) && n._pointerEvents.delete(e.pointerId), n._active && n._pointerEvents.size < 2 && (n._active = !1, this.compute(e), this.emit());
+  }
+  gestureStart(e) {
+    e.cancelable && e.preventDefault();
+    const n = this.state;
+    n._active || (this.start(e), this.computeValues([e.scale, e.rotation]), n.origin = [e.clientX, e.clientY], this.compute(e), this.emit());
+  }
+  gestureMove(e) {
+    if (e.cancelable && e.preventDefault(), !this.state._active) return;
+    const n = this.state;
+    this.computeValues([e.scale, e.rotation]), n.origin = [e.clientX, e.clientY];
+    const s = n._movement;
+    n._movement = [e.scale - 1, e.rotation], n._delta = $.sub(n._movement, s), this.compute(e), this.emit();
+  }
+  gestureEnd(e) {
+    this.state._active && (this.state._active = !1, this.compute(e), this.emit());
+  }
+  wheel(e) {
+    const n = this.config.modifierKey;
+    n && (Array.isArray(n) ? !n.find((s) => e[s]) : !e[n]) || (this.state._active ? this.wheelChange(e) : this.wheelStart(e), this.timeoutStore.add("wheelEnd", this.wheelEnd.bind(this)));
+  }
+  wheelStart(e) {
+    this.start(e), this.wheelChange(e);
+  }
+  wheelChange(e) {
+    "uv" in e || (e.cancelable && e.preventDefault(), process.env.NODE_ENV === "development" && !e.defaultPrevented && console.warn("[@use-gesture]: To properly support zoom on trackpads, try using the `target` option.\n\nThis message will only appear in development mode."));
+    const s = this.state;
+    s._delta = [-dn(e)[1] / Os * s.offset[0], 0], $.addTo(s._movement, s._delta), mn(s), this.state.origin = [e.clientX, e.clientY], this.compute(e), this.emit();
+  }
+  wheelEnd() {
+    this.state._active && (this.state._active = !1, this.compute(), this.emit());
+  }
+  bind(e) {
+    const n = this.config.device;
+    n && (e(n, "start", this[n + "Start"].bind(this)), e(n, "change", this[n + "Move"].bind(this)), e(n, "end", this[n + "End"].bind(this)), e(n, "cancel", this[n + "End"].bind(this)), e("lostPointerCapture", "", this[n + "End"].bind(this))), this.config.pinchOnWheel && e("wheel", "", this.wheel.bind(this), {
+      passive: !1
+    });
+  }
+}
+const Ns = Y(Y({}, wt), {}, {
+  device(t, e, {
+    shared: n,
+    pointer: {
+      touch: s = !1
+    } = {}
+  }) {
+    if (n.target && !ne.touch && ne.gesture) return "gesture";
+    if (ne.touch && s) return "touch";
+    if (ne.touchscreen) {
+      if (ne.pointer) return "pointer";
+      if (ne.touch) return "touch";
+    }
+  },
+  bounds(t, e, {
+    scaleBounds: n = {},
+    angleBounds: s = {}
+  }) {
+    const r = (o) => {
+      const a = Vt(Ue(n, o), {
+        min: -1 / 0,
+        max: 1 / 0
+      });
+      return [a.min, a.max];
+    }, i = (o) => {
+      const a = Vt(Ue(s, o), {
+        min: -1 / 0,
+        max: 1 / 0
+      });
+      return [a.min, a.max];
+    };
+    return typeof n != "function" && typeof s != "function" ? [r(), i()] : (o) => [r(o), i(o)];
+  },
+  threshold(t, e, n) {
+    return this.lockDirection = n.axis === "lock", $.toVector(t, this.lockDirection ? [0.1, 3] : 0);
+  },
+  modifierKey(t) {
+    return t === void 0 ? "ctrlKey" : t;
+  },
+  pinchOnWheel(t = !0) {
+    return t;
+  }
+});
+class As extends Oe {
+  constructor(...e) {
+    super(...e), X(this, "ingKey", "moving");
+  }
+  move(e) {
+    this.config.mouseOnly && e.pointerType !== "mouse" || (this.state._active ? this.moveChange(e) : this.moveStart(e), this.timeoutStore.add("moveEnd", this.moveEnd.bind(this)));
+  }
+  moveStart(e) {
+    this.start(e), this.computeValues(xe(e)), this.compute(e), this.computeInitial(), this.emit();
+  }
+  moveChange(e) {
+    if (!this.state._active) return;
+    const n = xe(e), s = this.state;
+    s._delta = $.sub(n, s._values), $.addTo(s._movement, s._delta), this.computeValues(n), this.compute(e), this.emit();
+  }
+  moveEnd(e) {
+    this.state._active && (this.state._active = !1, this.compute(e), this.emit());
+  }
+  bind(e) {
+    e("pointer", "change", this.move.bind(this)), e("pointer", "leave", this.moveEnd.bind(this));
+  }
+}
+const Cs = Y(Y({}, pe), {}, {
+  mouseOnly: (t = !0) => t
+});
+class Ms extends Oe {
+  constructor(...e) {
+    super(...e), X(this, "ingKey", "scrolling");
+  }
+  scroll(e) {
+    this.state._active || this.start(e), this.scrollChange(e), this.timeoutStore.add("scrollEnd", this.scrollEnd.bind(this));
+  }
+  scrollChange(e) {
+    e.cancelable && e.preventDefault();
+    const n = this.state, s = us(e);
+    n._delta = $.sub(s, n._values), $.addTo(n._movement, n._delta), this.computeValues(s), this.compute(e), this.emit();
+  }
+  scrollEnd() {
+    this.state._active && (this.state._active = !1, this.compute(), this.emit());
+  }
+  bind(e) {
+    e("scroll", "", this.scroll.bind(this));
+  }
+}
+const js = pe;
+class zs extends Oe {
+  constructor(...e) {
+    super(...e), X(this, "ingKey", "wheeling");
+  }
+  wheel(e) {
+    this.state._active || this.start(e), this.wheelChange(e), this.timeoutStore.add("wheelEnd", this.wheelEnd.bind(this));
+  }
+  wheelChange(e) {
+    const n = this.state;
+    n._delta = dn(e), $.addTo(n._movement, n._delta), mn(n), this.compute(e), this.emit();
+  }
+  wheelEnd() {
+    this.state._active && (this.state._active = !1, this.compute(), this.emit());
+  }
+  bind(e) {
+    e("wheel", "", this.wheel.bind(this));
+  }
+}
+const Ls = pe;
+class $s extends Oe {
+  constructor(...e) {
+    super(...e), X(this, "ingKey", "hovering");
+  }
+  enter(e) {
+    this.config.mouseOnly && e.pointerType !== "mouse" || (this.start(e), this.computeValues(xe(e)), this.compute(e), this.emit());
+  }
+  leave(e) {
+    if (this.config.mouseOnly && e.pointerType !== "mouse") return;
+    const n = this.state;
+    if (!n._active) return;
+    n._active = !1;
+    const s = xe(e);
+    n._movement = n._delta = $.sub(s, n._values), this.computeValues(s), this.compute(e), n.delta = n.movement, this.emit();
+  }
+  bind(e) {
+    e("pointer", "enter", this.enter.bind(this)), e("pointer", "leave", this.leave.bind(this));
+  }
+}
+const Hs = Y(Y({}, pe), {}, {
+  mouseOnly: (t = !0) => t
+}), xt = /* @__PURE__ */ new Map(), ft = /* @__PURE__ */ new Map();
+function Vs(t) {
+  xt.set(t.key, t.engine), ft.set(t.key, t.resolver);
+}
+const Ys = {
+  key: "drag",
+  engine: ys,
+  resolver: pn
+}, Fs = {
+  key: "hover",
+  engine: $s,
+  resolver: Hs
+}, Us = {
+  key: "move",
+  engine: As,
+  resolver: Cs
+}, Bs = {
+  key: "pinch",
+  engine: Rs,
+  resolver: Ns
+}, Xs = {
+  key: "scroll",
+  engine: Ms,
+  resolver: js
+}, Ws = {
+  key: "wheel",
+  engine: zs,
+  resolver: Ls
+};
+function Ks(t, e) {
+  if (t == null) return {};
+  var n = {}, s = Object.keys(t), r, i;
+  for (i = 0; i < s.length; i++)
+    r = s[i], !(e.indexOf(r) >= 0) && (n[r] = t[r]);
+  return n;
+}
+function Gs(t, e) {
+  if (t == null) return {};
+  var n = Ks(t, e), s, r;
+  if (Object.getOwnPropertySymbols) {
+    var i = Object.getOwnPropertySymbols(t);
+    for (r = 0; r < i.length; r++)
+      s = i[r], !(e.indexOf(s) >= 0) && Object.prototype.propertyIsEnumerable.call(t, s) && (n[s] = t[s]);
+  }
+  return n;
+}
+const qs = {
+  target(t) {
+    if (t)
+      return () => "current" in t ? t.current : t;
+  },
+  enabled(t = !0) {
+    return t;
+  },
+  window(t = ne.isBrowser ? window : void 0) {
+    return t;
+  },
+  eventOptions({
+    passive: t = !0,
+    capture: e = !1
+  } = {}) {
+    return {
+      passive: t,
+      capture: e
+    };
+  },
+  transform(t) {
+    return t;
+  }
+}, Js = ["target", "eventOptions", "window", "enabled", "transform"];
+function ze(t = {}, e) {
+  const n = {};
+  for (const [s, r] of Object.entries(e))
+    switch (typeof r) {
+      case "function":
+        if (process.env.NODE_ENV === "development") {
+          const i = r.call(n, t[s], s, t);
+          Number.isNaN(i) || (n[s] = i);
+        } else
+          n[s] = r.call(n, t[s], s, t);
+        break;
+      case "object":
+        n[s] = ze(t[s], r);
+        break;
+      case "boolean":
+        r && (n[s] = t[s]);
+        break;
+    }
+  return n;
+}
+function Zs(t, e, n = {}) {
+  const s = t, {
+    target: r,
+    eventOptions: i,
+    window: o,
+    enabled: a,
+    transform: l
+  } = s, d = Gs(s, Js);
+  if (n.shared = ze({
+    target: r,
+    eventOptions: i,
+    window: o,
+    enabled: a,
+    transform: l
+  }, qs), e) {
+    const f = ft.get(e);
+    n[e] = ze(Y({
+      shared: n.shared
+    }, d), f);
+  } else
+    for (const f in d) {
+      const v = ft.get(f);
+      if (v)
+        n[f] = ze(Y({
+          shared: n.shared
+        }, d[f]), v);
+      else if (process.env.NODE_ENV === "development" && !["drag", "pinch", "scroll", "wheel", "move", "hover"].includes(f)) {
+        if (f === "domTarget")
+          throw Error("[@use-gesture]: `domTarget` option has been renamed to `target`.");
+        console.warn(`[@use-gesture]: Unknown config key \`${f}\` was used. Please read the documentation for further information.`);
+      }
+    }
+  return n;
+}
+class gn {
+  constructor(e, n) {
+    X(this, "_listeners", /* @__PURE__ */ new Set()), this._ctrl = e, this._gestureKey = n;
+  }
+  add(e, n, s, r, i) {
+    const o = this._listeners, a = os(n, s), l = this._gestureKey ? this._ctrl.config[this._gestureKey].eventOptions : {}, d = Y(Y({}, l), i);
+    e.addEventListener(a, r, d);
+    const f = () => {
+      e.removeEventListener(a, r, d), o.delete(f);
+    };
+    return o.add(f), f;
+  }
+  clean() {
+    this._listeners.forEach((e) => e()), this._listeners.clear();
+  }
+}
+class Qs {
+  constructor() {
+    X(this, "_timeouts", /* @__PURE__ */ new Map());
+  }
+  add(e, n, s = 140, ...r) {
+    this.remove(e), this._timeouts.set(e, window.setTimeout(n, s, ...r));
+  }
+  remove(e) {
+    const n = this._timeouts.get(e);
+    n && window.clearTimeout(n);
+  }
+  clean() {
+    this._timeouts.forEach((e) => void window.clearTimeout(e)), this._timeouts.clear();
+  }
+}
+class er {
+  constructor(e) {
+    X(this, "gestures", /* @__PURE__ */ new Set()), X(this, "_targetEventStore", new gn(this)), X(this, "gestureEventStores", {}), X(this, "gestureTimeoutStores", {}), X(this, "handlers", {}), X(this, "config", {}), X(this, "pointerIds", /* @__PURE__ */ new Set()), X(this, "touchIds", /* @__PURE__ */ new Set()), X(this, "state", {
+      shared: {
+        shiftKey: !1,
+        metaKey: !1,
+        ctrlKey: !1,
+        altKey: !1
+      }
+    }), tr(this, e);
+  }
+  setEventIds(e) {
+    if (Je(e))
+      return this.touchIds = new Set(ls(e)), this.touchIds;
+    if ("pointerId" in e)
+      return e.type === "pointerup" || e.type === "pointercancel" ? this.pointerIds.delete(e.pointerId) : e.type === "pointerdown" && this.pointerIds.add(e.pointerId), this.pointerIds;
+  }
+  applyHandlers(e, n) {
+    this.handlers = e, this.nativeHandlers = n;
+  }
+  applyConfig(e, n) {
+    this.config = Zs(e, n, this.config);
+  }
+  clean() {
+    this._targetEventStore.clean();
+    for (const e of this.gestures)
+      this.gestureEventStores[e].clean(), this.gestureTimeoutStores[e].clean();
+  }
+  effect() {
+    return this.config.shared.target && this.bind(), () => this._targetEventStore.clean();
+  }
+  bind(...e) {
+    const n = this.config.shared, s = {};
+    let r;
+    if (!(n.target && (r = n.target(), !r))) {
+      if (n.enabled) {
+        for (const o of this.gestures) {
+          const a = this.config[o], l = Xt(s, a.eventOptions, !!r);
+          if (a.enabled) {
+            const d = xt.get(o);
+            new d(this, e, o).bind(l);
+          }
+        }
+        const i = Xt(s, n.eventOptions, !!r);
+        for (const o in this.nativeHandlers)
+          i(o, "", (a) => this.nativeHandlers[o](Y(Y({}, this.state.shared), {}, {
+            event: a,
+            args: e
+          })), void 0, !0);
+      }
+      for (const i in s)
+        s[i] = hs(...s[i]);
+      if (!r) return s;
+      for (const i in s) {
+        const {
+          device: o,
+          capture: a,
+          passive: l
+        } = is(i);
+        this._targetEventStore.add(r, o, "", s[i], {
+          capture: a,
+          passive: l
+        });
+      }
+    }
+  }
+}
+function ye(t, e) {
+  t.gestures.add(e), t.gestureEventStores[e] = new gn(t, e), t.gestureTimeoutStores[e] = new Qs();
+}
+function tr(t, e) {
+  e.drag && ye(t, "drag"), e.wheel && ye(t, "wheel"), e.scroll && ye(t, "scroll"), e.move && ye(t, "move"), e.pinch && ye(t, "pinch"), e.hover && ye(t, "hover");
+}
+const Xt = (t, e, n) => (s, r, i, o = {}, a = !1) => {
+  var l, d;
+  const f = (l = o.capture) !== null && l !== void 0 ? l : e.capture, v = (d = o.passive) !== null && d !== void 0 ? d : e.passive;
+  let m = a ? s : ss(s, r, f);
+  n && v && (m += "Passive"), t[m] = t[m] || [], t[m].push(i);
+}, nr = /^on(Drag|Wheel|Scroll|Move|Pinch|Hover)/;
+function sr(t) {
+  const e = {}, n = {}, s = /* @__PURE__ */ new Set();
+  for (let r in t)
+    nr.test(r) ? (s.add(RegExp.lastMatch), n[r] = t[r]) : e[r] = t[r];
+  return [n, e, s];
+}
+function _e(t, e, n, s, r, i) {
+  if (!t.has(n)) return;
+  if (!xt.has(s)) {
+    process.env.NODE_ENV === "development" && console.warn(`[@use-gesture]: You've created a custom handler that that uses the \`${s}\` gesture but isn't properly configured.
+
+Please add \`${s}Action\` when creating your handler.`);
+    return;
+  }
+  const o = n + "Start", a = n + "End", l = (d) => {
+    let f;
+    return d.first && o in e && e[o](d), n in e && (f = e[n](d)), d.last && a in e && e[a](d), f;
+  };
+  r[s] = l, i[s] = i[s] || {};
+}
+function rr(t, e) {
+  const [n, s, r] = sr(t), i = {};
+  return _e(r, n, "onDrag", "drag", i, e), _e(r, n, "onWheel", "wheel", i, e), _e(r, n, "onScroll", "scroll", i, e), _e(r, n, "onPinch", "pinch", i, e), _e(r, n, "onMove", "move", i, e), _e(r, n, "onHover", "hover", i, e), {
+    handlers: i,
+    config: e,
+    nativeHandlers: s
+  };
+}
+function ir(t, e = {}, n, s) {
+  const r = re.useMemo(() => new er(t), []);
+  if (r.applyHandlers(t, s), r.applyConfig(e, n), re.useEffect(r.effect.bind(r)), re.useEffect(() => r.clean.bind(r), []), e.target === void 0)
+    return r.bind.bind(r);
+}
+function or(t) {
+  return t.forEach(Vs), function(n, s) {
+    const {
+      handlers: r,
+      nativeHandlers: i,
+      config: o
+    } = rr(n, s || {});
+    return ir(r, o, void 0, i);
+  };
+}
+function Ne(t, e) {
+  return or([Ys, Bs, Xs, Ws, Us, Fs])(t, e || {});
+}
+const ar = ({ pos: t, onDragStart: e, onDragMove: n, onDragEnd: s, className: r = "", style: i }) => {
+  const o = Ne(
+    {
+      onDrag: ({ first: a, movement: [l, d], memo: f, event: v }) => (v.stopPropagation(), a ? e() : (f && n(t, l, d, f), f)),
+      onDragEnd: ({ movement: [a, l], memo: d, event: f }) => {
+        f.stopPropagation(), d && s(t, a, l, d);
+      }
+    },
+    { drag: { filterTaps: !0, threshold: 0 } }
+  );
+  return /* @__PURE__ */ y.jsx(
+    "div",
+    {
+      className: `ce-resize-handle ce-resize-handle--${t} ${r}`,
+      style: { touchAction: "none", ...i },
+      ...o()
+    }
+  );
+}, cr = ({ onDragStart: t, onDragMove: e, onDragEnd: n, className: s = "", style: r }) => {
+  const i = Ne(
+    {
+      onDrag: ({ first: o, movement: [a, l], memo: d, event: f }) => (f.stopPropagation(), o ? t(a, l) : (d && e(a, l, d), d)),
+      onDragEnd: ({ movement: [o, a], memo: l, event: d }) => {
+        d.stopPropagation(), l && n(o, a, l);
+      }
+    },
+    { drag: { filterTaps: !0, threshold: 0 } }
+  );
+  return /* @__PURE__ */ y.jsx(
+    "div",
+    {
+      className: `ce-rotate-handle ${s}`,
+      style: { touchAction: "none", ...r },
+      ...i(),
+      children: /* @__PURE__ */ y.jsx("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ y.jsx("path", { d: "M21 12a9 9 0 1 1-6.219-8.56" }) })
+    }
+  );
+}, yn = ({ lines: t, className: e = "", style: n }) => t.length ? /* @__PURE__ */ y.jsx(y.Fragment, { children: t.map((s, r) => /* @__PURE__ */ y.jsx(
+  "div",
+  {
+    className: `ce-snap-guide ce-snap-guide--${s.type} ${e}`,
+    style: {
+      left: s.type === "vertical" ? s.pos : 0,
+      top: s.type === "horizontal" ? s.pos : 0,
+      ...n
+    }
+  },
+  r
+)) }) : null, Wt = 5, _n = (t, e, n, s, r, i) => {
+  let o = e, a = n;
+  const l = [], d = [e, e + s / 2, e + s], f = [n, n + r / 2, n + r];
+  return Object.values(i).forEach((v) => {
+    if (v.id === t) return;
+    const m = [v.x, v.x + v.width / 2, v.x + v.width];
+    d.forEach((O, R) => {
+      m.forEach((c) => {
+        Math.abs(O - c) < Wt && (R === 0 && (o = c), R === 1 && (o = c - s / 2), R === 2 && (o = c - s), l.push({ type: "vertical", pos: c }));
+      });
+    });
+    const w = [v.y, v.y + v.height / 2, v.y + v.height];
+    f.forEach((O, R) => {
+      w.forEach((c) => {
+        Math.abs(O - c) < Wt && (R === 0 && (a = c), R === 1 && (a = c - r / 2), R === 2 && (a = c - r), l.push({ type: "horizontal", pos: c }));
+      });
+    });
+  }), { x: o, y: a, lines: l };
+}, Kt = (t, e, n, s, r, i, o) => {
+  let l = s, d = r, f = e, v = n;
+  const m = [], w = e, O = e + s, R = e + s / 2, c = n, g = n + r, p = n + r / 2, b = i.includes("w"), _ = i.includes("e"), k = i.includes("n"), h = i.includes("s"), D = i === "n" || i === "s", T = i === "e" || i === "w";
+  Object.values(o).forEach((S) => {
+    if (S.id === t) return;
+    const M = S.x, j = S.x + S.width, x = S.x + S.width / 2, U = S.y, G = S.y + S.height, K = S.y + S.height / 2;
+    if (_ && [M, j, x].forEach((L) => {
+      Math.abs(O - L) < 5 && (l = L - e, m.push({ type: "vertical", pos: L }));
+    }), b) {
+      const L = e + s;
+      [M, j, x].forEach((F) => {
+        Math.abs(w - F) < 5 && (f = F, l = L - F, m.push({ type: "vertical", pos: F }));
+      });
+    }
+    if (D && Math.abs(R - x) < 5 && (f = x - s / 2, m.push({ type: "vertical", pos: x })), h && [U, G, K].forEach((L) => {
+      Math.abs(g - L) < 5 && (d = L - n, m.push({ type: "horizontal", pos: L }));
+    }), k) {
+      const L = n + r;
+      [U, G, K].forEach((F) => {
+        Math.abs(c - F) < 5 && (v = F, d = L - F, m.push({ type: "horizontal", pos: F }));
+      });
+    }
+    T && Math.abs(p - K) < 5 && (v = K - r / 2, m.push({ type: "horizontal", pos: K }));
+  });
+  const I = 10;
+  return l < I && (b && (f = e + s - I), l = I), d < I && (k && (v = n + r - I), d = I), {
+    x: f,
+    y: v,
+    width: l,
+    height: d,
+    lines: m
+  };
+}, Gt = (t, e, n, s, r, i, o, a) => {
+  let l = 0.5, d = 0.5;
+  i.includes("n") && (d = 1), i.includes("s") && (d = 0), i.includes("e") && (l = 0), i.includes("w") && (l = 1);
+  const f = r * Math.PI / 180, v = Math.cos(f), m = Math.sin(f), w = t + n / 2, O = e + s / 2, R = n * l - n / 2, c = s * d - s / 2, g = w + (R * v - c * m), p = O + (R * m + c * v), b = Math.cos(-f), _ = Math.sin(-f), k = o * b - a * _, h = o * _ + a * b;
+  let D = 0, T = 0;
+  i.includes("e") && (D = k), i.includes("w") && (D = -k), i.includes("s") && (T = h), i.includes("n") && (T = -h);
+  const I = Math.max(10, n + D), S = Math.max(10, s + T), M = I * l - I / 2, j = S * d - S / 2, x = M * v - j * m, U = M * m + j * v, G = g - x, K = p - U, L = G - I / 2, F = K - S / 2;
+  return {
+    x: L,
+    y: F,
+    width: I,
+    height: S
+  };
+}, lr = ({
+  id: t,
+  children: e,
+  className: n = "",
+  style: s,
+  draggable: r,
+  resizable: i,
+  rotatable: o,
+  selectable: a,
+  rotationSnap: l,
+  showDragHandle: d,
+  doubleClickToEdit: f,
+  ...v
+}) => {
+  const m = C((E) => E.nodes[t]), w = C((E) => E.config), O = C((E) => E.config.viewOnly || a === !1 ? !1 : E.selectedIds?.includes(t)), R = C((E) => E.camera.zoom), c = bt(), g = C((E) => E.selectNode), p = C((E) => E.updateNode), b = ve(null), [_, k] = Le([]), [h, D] = Le(!1), T = ve(!1);
+  ie(() => {
+    O || (k([]), D(!1));
+  }, [O]);
+  const I = ve(m);
+  ie(() => {
+    I.current = m;
+  }, [m]);
+  const S = !w.viewOnly, M = (E, A) => E !== void 0 ? E : A !== void 0 ? A : !0, j = S && M(r, m?.draggable), x = S && M(i, m?.resizable), U = S && M(o, m?.rotatable), G = S && a !== !1, K = S && j && d !== !1, L = f !== void 0 ? f : m?.doubleClickToEdit ?? m?.data?.doubleClickToEdit ?? !1, F = () => typeof l == "number" ? l : l === !1 ? 0 : l === !0 ? w.rotationSnap || 15 : w.rotationSnap || 0, ue = Ne(
+    {
+      onDragStart: ({ event: E }) => {
+        if (!S) return;
+        const A = E.target;
+        A.closest(".ce-resize-handle") || A.closest(".ce-rotate-handle") || h && !A.closest(".ce-drag-handle-minimal") || G && !O && g(t);
+      },
+      onDrag: ({ movement: [E, A], first: W, memo: z, event: Z }) => {
+        if (!S || !j) return;
+        const V = Z.target;
+        if (V.closest(".ce-resize-handle") || V.closest(".ce-rotate-handle") || h && !V.closest(".ce-drag-handle-minimal") || T.current || (Z && Z.stopPropagation(), !m)) return;
+        if (W) return { x: m.x, y: m.y };
+        const P = c.getState().nodes, J = z?.x ?? m.x, oe = z?.y ?? m.y;
+        let de = J + E / R, se = oe + A / R;
+        if (w.snapping) {
+          const ae = _n(t, de, se, m.width, m.height, P);
+          de = ae.x, se = ae.y, w.snapGuide && k(ae.lines);
+        }
+        if (w.isLimited) {
+          const ae = (w.width || 1920) - m.width, vn = (w.height || 1080) - m.height;
+          de = Math.max(0, Math.min(de, ae)), se = Math.max(0, Math.min(se, vn));
+        }
+        return b.current && (b.current.style.transform = `translate(${de}px, ${se}px) rotate(${m.rotation}deg)`), { x: J, y: oe, finalX: de, finalY: se };
+      },
+      onDragEnd: ({ memo: E, event: A }) => {
+        A && A.stopPropagation(), k([]), E && typeof E.finalX == "number" && p(t, { x: E.finalX, y: E.finalY });
+      }
+    },
+    { drag: { filterTaps: !0, threshold: 3, enabled: S } }
+  ), te = ge(() => {
+    T.current = !0;
+    const E = I.current;
+    return E ? {
+      x: E.x,
+      y: E.y,
+      w: E.width,
+      h: E.height,
+      r: E.rotation || 0
+    } : { x: 0, y: 0, w: 0, h: 0, r: 0 };
+  }, []), u = ge((E, A, W, z) => {
+    if (!b.current) return;
+    const Z = c.getState().nodes, V = Gt(
+      z.x,
+      z.y,
+      z.w,
+      z.h,
+      z.r,
+      E,
+      A / R,
+      W / R
+    );
+    let P = { x: V.x, y: V.y, width: V.width, height: V.height, lines: [] };
+    if (w.snapping ? P = Kt(
+      t,
+      V.x,
+      V.y,
+      V.width,
+      V.height,
+      E,
+      Z
+    ) : P = { ...V, lines: [] }, w.isLimited) {
+      const J = w.width || 1920, oe = w.height || 1080;
+      P.x < 0 && (P.width += P.x, P.x = 0), P.y < 0 && (P.height += P.y, P.y = 0), P.x + P.width > J && (P.width = J - P.x), P.y + P.height > oe && (P.height = oe - P.y);
+    }
+    w.snapGuide && k(P.lines), b.current.style.width = `${P.width}px`, b.current.style.height = `${P.height}px`, b.current.style.transform = `translate(${P.x}px, ${P.y}px) rotate(${z.r}deg)`;
+  }, [t, R, w, c]), N = ge((E, A, W, z) => {
+    const Z = c.getState().nodes, V = Gt(z.x, z.y, z.w, z.h, z.r, E, A / R, W / R);
+    let P = { ...V };
+    if (w.snapping && (P = Kt(t, V.x, V.y, V.width, V.height, E, Z)), w.isLimited) {
+      const J = w.width || 1920, oe = w.height || 1080;
+      P.x < 0 && (P.width += P.x, P.x = 0), P.y < 0 && (P.height += P.y, P.y = 0), P.x + P.width > J && (P.width = J - P.x), P.y + P.height > oe && (P.height = oe - P.y);
+    }
+    p(t, {
+      x: P.x,
+      y: P.y,
+      width: P.width,
+      height: P.height
+    }), k([]), setTimeout(() => {
+      T.current = !1;
+    }, 100);
+  }, [t, R, p, w, c]), H = ge((E, A) => {
+    T.current = !0;
+    const W = I.current;
+    if (!W || !b.current) return { startRotation: 0, startAngle: 0 };
+    const z = b.current.getBoundingClientRect(), Z = z.left + z.width / 2, V = z.top + z.height / 2;
+    let J = Math.atan2(A - V, E - Z) * (180 / Math.PI);
+    return J += 90, { startRotation: W.rotation, startAngle: J };
+  }, []), B = ge((E, A, W) => {
+    if (!b.current || !I.current) return;
+    const z = b.current.getBoundingClientRect(), Z = z.left + z.width / 2, V = z.top + z.height / 2;
+    let J = Math.atan2(A - V, E - Z) * (180 / Math.PI);
+    J += 90;
+    const oe = J - W.startAngle, de = w.rotationSpeed || 1;
+    let se = W.startRotation + oe * de;
+    const ae = F();
+    ae > 0 && (se = Math.round(se / ae) * ae), b.current.style.transform = `translate(${I.current.x}px, ${I.current.y}px) rotate(${se}deg)`, b.current.__tempRotation = se;
+  }, [w.rotationSpeed, F]), me = ge(() => {
+    const E = b.current.__tempRotation;
+    typeof E == "number" && (p(t, { rotation: E }), delete b.current.__tempRotation), setTimeout(() => {
+      T.current = !1;
+    }, 100);
+  }, [t, p]);
+  return m ? /* @__PURE__ */ y.jsxs(y.Fragment, { children: [
+    /* @__PURE__ */ y.jsx(yn, { lines: _ }),
+    /* @__PURE__ */ y.jsxs(
+      "div",
+      {
+        ref: b,
+        "data-node-id": t,
+        className: `ce-element ${O ? "ce-element--selected" : ""} ${n}`,
+        style: {
+          transform: `translate(${m.x}px, ${m.y}px) rotate(${m.rotation}deg)`,
+          width: m.width,
+          height: m.height,
+          zIndex: O ? 100 : 1,
+          "--ce-inverse-zoom": 1 / R,
+          // Inject inverse zoom for CSS scaling
+          ...s
+        },
+        ...ue(),
+        ...v,
+        onClick: (E) => {
+          E.stopPropagation(), S && G && g(t);
+        },
+        onDoubleClick: (E) => {
+          S && L && (E.stopPropagation(), D(!0));
+        },
+        children: [
+          /* @__PURE__ */ y.jsx("div", { style: {
+            width: "100%",
+            height: "100%",
+            pointerEvents: L && !h ? "none" : "auto"
+          }, children: e }),
+          O && S && /* @__PURE__ */ y.jsxs(y.Fragment, { children: [
+            K && /* @__PURE__ */ y.jsx("div", { className: "ce-drag-handle-minimal", children: /* @__PURE__ */ y.jsxs("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+              /* @__PURE__ */ y.jsx("polyline", { points: "5 9 2 12 5 15" }),
+              /* @__PURE__ */ y.jsx("polyline", { points: "9 5 12 2 15 5" }),
+              /* @__PURE__ */ y.jsx("polyline", { points: "19 9 22 12 19 15" }),
+              /* @__PURE__ */ y.jsx("polyline", { points: "9 19 12 22 15 19" }),
+              /* @__PURE__ */ y.jsx("path", { d: "M2 12h20" }),
+              /* @__PURE__ */ y.jsx("path", { d: "M12 2v20" })
+            ] }) }),
+            x && ["nw", "ne", "sw", "se", "n", "s", "e", "w"].map((E) => /* @__PURE__ */ y.jsx(
+              ar,
+              {
+                pos: E,
+                onDragStart: te,
+                onDragMove: u,
+                onDragEnd: N
+              },
+              E
+            )),
+            w.rotation && U && /* @__PURE__ */ y.jsx(
+              cr,
+              {
+                onDragStart: H,
+                onDragMove: B,
+                onDragEnd: me
+              }
+            )
+          ] })
+        ]
+      }
+    )
+  ] }) : null;
+}, ur = re.memo(lr), dr = ({
+  id: t,
+  children: e,
+  className: n = "",
+  style: s,
+  draggable: r = !0,
+  selectable: i = !0
+}) => {
+  const o = C((_) => _.nodes[t]), a = C((_) => _.config), l = bt(), d = C((_) => _.removeNode), f = C((_) => _.config.viewOnly || !i ? !1 : _.selectedIds?.includes(t)), v = C((_) => _.camera.zoom), m = C((_) => _.selectNode), w = C((_) => _.updateNode), O = ve(null), [R, c] = Le([]);
+  if (ie(() => {
+    f || c([]);
+  }, [f]), ie(() => {
+    if (!O.current) return;
+    const _ = new ResizeObserver((k) => {
+      for (const h of k) {
+        const { width: D, height: T } = h.contentRect;
+        o && (Math.abs(o.width - D) > 1 || Math.abs(o.height - T) > 1) && w(t, { width: D, height: T });
+      }
+    });
+    return _.observe(O.current), () => _.disconnect();
+  }, [t, o?.width, o?.height, w]), !o) return null;
+  const g = !a.viewOnly, p = g && r && o.draggable !== !1, b = Ne(
+    {
+      onDragStart: ({ event: _ }) => {
+        if (!g) return;
+        const k = _.target;
+        k.tagName === "INPUT" || k.tagName === "TEXTAREA" || i && !f && m(t);
+      },
+      onDrag: ({ movement: [_, k], first: h, memo: D, event: T }) => {
+        if (!p) return;
+        if (T && T.stopPropagation(), h) return { x: o.x, y: o.y };
+        const I = l.getState().nodes, S = D?.x ?? o.x, M = D?.y ?? o.y;
+        let j = S + _ / v, x = M + k / v;
+        if (a.snapping) {
+          const U = _n(t, j, x, o.width, o.height, I);
+          j = U.x, x = U.y, a.snapGuide && c(U.lines);
+        }
+        return w(t, { x: j, y: x }), O.current && (O.current.style.transform = `translate(${j}px, ${x}px)`), { x: S, y: M, finalX: j, finalY: x };
+      },
+      onDragEnd: ({ event: _ }) => {
+        _ && _.stopPropagation(), c([]);
+      }
+    },
+    { drag: { filterTaps: !0, threshold: 3, enabled: p } }
+  );
+  return /* @__PURE__ */ y.jsxs(y.Fragment, { children: [
+    a.snapGuide && /* @__PURE__ */ y.jsx(yn, { lines: R }),
+    /* @__PURE__ */ y.jsxs(
+      "div",
+      {
+        ref: O,
+        "data-node-id": t,
+        className: `ce-element ce-workflow-node ${f ? "ce-element--selected" : ""} ${n}`,
+        style: {
+          position: "absolute",
+          left: 0,
+          top: 0,
+          width: "max-content",
+          transform: `translate(${o.x}px, ${o.y}px)`,
+          zIndex: f ? 10 : 1,
+          cursor: p ? "grab" : "default",
+          touchAction: "none",
+          ...s
+        },
+        ...b(),
+        onClick: (_) => {
+          _.stopPropagation(), g && i && m(t);
+        },
+        children: [
+          o.customCss && /* @__PURE__ */ y.jsx("style", { children: `
+                        [data-node-id="${t}"] {
+                            ${o.customCss}
+                        }
+                    ` }),
+          /* @__PURE__ */ y.jsx(Wn, { id: t, children: e }),
+          g && !a.viewOnly && /* @__PURE__ */ y.jsx(
+            "button",
+            {
+              className: "ce-delete-node-btn",
+              onPointerDown: (_) => _.stopPropagation(),
+              onClick: (_) => {
+                _.stopPropagation(), d(t);
+              },
+              title: "Remove Node",
+              children: "×"
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}, fr = re.memo(dr), hr = () => {
+  const t = C((c) => c.edges), e = C((c) => c.nodes), n = C((c) => c.connectionState), s = C((c) => c.selectNode), r = C((c) => c.selectedIds), i = C((c) => c.removeEdge), o = (c, g, p, b, _) => {
+    const k = 1 - c;
+    return Math.pow(k, 3) * g + 3 * Math.pow(k, 2) * c * p + 3 * k * Math.pow(c, 2) * b + Math.pow(c, 3) * _;
+  }, a = (c, g, p, b) => {
+    const _ = Math.abs(p - c) / 2, k = c + _, h = g, D = p - _;
+    return `M ${c} ${g} C ${k} ${h}, ${D} ${b}, ${p} ${b}`;
+  }, l = (c, g, p, b) => `M ${c} ${g} L ${p} ${b}`, d = (c, g, p, b) => {
+    const _ = (c + p) / 2;
+    return `M ${c} ${g} L ${_} ${g} L ${_} ${b} L ${p} ${b}`;
+  }, f = (c, g, p, b, _) => {
+    switch (c) {
+      case "straight":
+        return l(g, p, b, _);
+      case "step":
+        return d(g, p, b, _);
+      default:
+        return a(g, p, b, _);
+    }
+  }, v = C((c) => c.camera), m = C((c) => c.dimensions), O = tt(() => m.width === 0 || m.height === 0 ? Object.values(t) : Object.values(t).filter((c) => {
+    const g = e[c.source], p = e[c.target];
+    if (!g || !p) return !1;
+    const b = Math.min(g.x, p.x), _ = Math.max(g.x + g.width, p.x + p.width), k = Math.min(g.y, p.y), h = Math.max(g.y + g.height, p.y + p.height), D = v.zoom, T = b * D + v.x, I = _ * D + v.x, S = k * D + v.y, M = h * D + v.y, j = 100;
+    return !(I < -j || T > m.width + j || M < -j || S > m.height + j);
+  }), [t, e, v, m]).map((c) => {
+    const g = e[c.source], p = e[c.target];
+    if (!g || !p) return null;
+    let b = g.x + g.width / 2, _ = g.y + g.height / 2, k = p.x + p.width / 2, h = p.y + p.height / 2;
+    if (g.handles && c.sourceHandle && g.handles[c.sourceHandle]) {
+      const x = g.handles[c.sourceHandle];
+      typeof x.x == "number" && typeof x.y == "number" && x.x !== 0 ? (b = g.x + x.x, _ = g.y + x.y) : x.position === "top" ? (b = g.x + g.width / 2, _ = g.y) : x.position === "bottom" ? (b = g.x + g.width / 2, _ = g.y + g.height) : x.position === "left" ? (b = g.x, _ = g.y + g.height / 2) : x.position === "right" && (b = g.x + g.width, _ = g.y + g.height / 2);
+    }
+    if (p.handles && c.targetHandle && p.handles[c.targetHandle]) {
+      const x = p.handles[c.targetHandle];
+      typeof x.x == "number" && typeof x.y == "number" && x.x !== 0 ? (k = p.x + x.x, h = p.y + x.y) : x.position === "top" ? (k = p.x + p.width / 2, h = p.y) : x.position === "bottom" ? (k = p.x + p.width / 2, h = p.y + p.height) : x.position === "left" ? (k = p.x, h = p.y + p.height / 2) : x.position === "right" && (k = p.x + p.width, h = p.y + p.height / 2);
+    }
+    const D = f(c.type, b, _, k, h), T = r.includes(c.id), I = (b + k) / 2, S = (_ + h) / 2;
+    let M = I, j = S;
+    if (!c.type || c.type === "default") {
+      const x = Math.abs(k - b) / 2;
+      M = o(0.5, b, b + x, k - x, k), j = o(0.5, _, _, h, h);
+    }
+    return /* @__PURE__ */ y.jsxs("g", { className: "ce-edge-group", style: { pointerEvents: "all" }, children: [
+      /* @__PURE__ */ y.jsx(
+        "path",
+        {
+          d: D,
+          stroke: "transparent",
+          strokeWidth: "20",
+          fill: "none",
+          style: { cursor: "pointer" },
+          onClick: (x) => {
+            x.stopPropagation(), s(c.id);
+          }
+        }
+      ),
+      /* @__PURE__ */ y.jsx(
+        "path",
+        {
+          d: D,
+          stroke: T ? "#3b82f6" : "#b1b1b7",
+          strokeWidth: T ? "3" : "2",
+          fill: "none",
+          markerEnd: "url(#arrow-closed)",
+          style: { pointerEvents: "none" }
+        }
+      ),
+      /* @__PURE__ */ y.jsx(
+        "foreignObject",
+        {
+          x: M - 10,
+          y: j - 10,
+          width: 20,
+          height: 20,
+          className: "ce-edge-delete-fo",
+          style: { overflow: "visible" },
+          children: /* @__PURE__ */ y.jsx(
+            "button",
+            {
+              className: "ce-edge-delete-btn",
+              onClick: (x) => {
+                x.stopPropagation(), i(c.id);
+              },
+              title: "Disconnect",
+              style: {
+                width: "20px",
+                height: "20px",
+                borderRadius: "50%",
+                background: "#ff4d4f",
+                color: "white",
+                border: "1px solid white",
+                padding: 0,
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                fontSize: "14px",
+                lineHeight: 1,
+                cursor: "pointer",
+                boxShadow: "0 2px 4px rgba(0,0,0,0.2)"
+              },
+              children: "×"
+            }
+          )
+        }
+      )
+    ] }, c.id);
+  });
+  let R = null;
+  if (n.isValid && n.nodeId && n.position && e[n.nodeId]) {
+    const c = e[n.nodeId];
+    let g = c.x + c.width / 2, p = c.y + c.height / 2;
+    if (n.handleId && c.handles && c.handles[n.handleId]) {
+      const h = c.handles[n.handleId];
+      typeof h.x == "number" && typeof h.y == "number" && h.x !== 0 ? (g = c.x + h.x, p = c.y + h.y) : h.position === "top" ? (g = c.x + c.width / 2, p = c.y) : h.position === "bottom" ? (g = c.x + c.width / 2, p = c.y + c.height) : h.position === "left" ? (g = c.x, p = c.y + c.height / 2) : h.position === "right" && (g = c.x + c.width, p = c.y + c.height / 2);
+    }
+    const b = n.position.x, _ = n.position.y, k = a(g, p, b, _);
+    R = /* @__PURE__ */ y.jsx(
+      "path",
+      {
+        d: k,
+        stroke: "#3b82f6",
+        strokeWidth: "2",
+        strokeDasharray: "5,5",
+        fill: "none",
+        markerEnd: "url(#arrow-closed)",
+        className: "ce-connection-line"
+      }
+    );
+  }
+  return /* @__PURE__ */ y.jsxs(
+    "svg",
+    {
+      className: "ce-edge-layer",
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: "100%",
+        overflow: "visible",
+        pointerEvents: "visible",
+        // Handled by children
+        zIndex: 0
+      },
+      children: [
+        /* @__PURE__ */ y.jsx("defs", { children: /* @__PURE__ */ y.jsx(
+          "marker",
+          {
+            id: "arrow-closed",
+            viewBox: "0 0 10 10",
+            refX: "9",
+            refY: "5",
+            markerWidth: "6",
+            markerHeight: "6",
+            orient: "auto-start-reverse",
+            children: /* @__PURE__ */ y.jsx("path", { d: "M 0 0 L 10 5 L 0 10 z", fill: "#b1b1b7" })
+          }
+        ) }),
+        O,
+        O,
+        R
+      ]
+    }
+  );
+}, yr = ({ children: t, grid: e, background: n, className: s = "", style: r, canvasStyle: i }) => {
+  const o = ve(null), a = C((h) => h.camera), l = C((h) => h.config), d = C((h) => h.panCamera), f = C((h) => h.zoomCamera), v = C((h) => h.deselectAll), m = C((h) => h.deleteSelected), w = C((h) => h.setDimensions);
+  ie(() => {
+    const h = (I) => {
+      I.ctrlKey && I.preventDefault();
+    }, D = o.current;
+    D && D.addEventListener("wheel", h, { passive: !1 });
+    let T = null;
+    return D && (T = new ResizeObserver((I) => {
+      for (const S of I) {
+        const { width: M, height: j } = S.contentRect;
+        w(M, j);
+      }
+    }), T.observe(D)), () => {
+      D && D.removeEventListener("wheel", h), T && T.disconnect();
+    };
+  }, [w]);
+  const [O, R] = Le(!1);
+  ie(() => {
+    const h = (T) => {
+      if (T.code === "Space" && !T.repeat && R(!0), (T.code === "Delete" || T.code === "Backspace") && !l.viewOnly) {
+        const I = T.target;
+        I.tagName !== "INPUT" && I.tagName !== "TEXTAREA" && m();
+      }
+    }, D = (T) => {
+      T.code === "Space" && R(!1);
+    };
+    return window.addEventListener("keydown", h), window.addEventListener("keyup", D), () => {
+      window.removeEventListener("keydown", h), window.removeEventListener("keyup", D);
+    };
+  }, [m, l.viewOnly]), Ne(
+    {
+      onDrag: ({ delta: [h, D], event: T }) => {
+        const I = T.target, S = I.closest(".ce-element") || I.closest(".ce-resize-handle");
+        (O || l.pan && !S) && d(h, D);
+      },
+      onWheel: ({ event: h, delta: [, D], ctrlKey: T }) => {
+        if (T || h.metaKey) {
+          if (l.zoom) {
+            const I = o.current?.getBoundingClientRect();
+            if (I) {
+              let S, M;
+              !l.pan && !O ? (S = (I.width || window.innerWidth) / 2, M = (I.height || window.innerHeight) / 2) : (S = h.clientX - I.left, M = h.clientY - I.top), f(1 - D / 500, S, M);
+            }
+          }
+        } else
+          d(-h.deltaX, -h.deltaY);
+      }
+    },
+    {
+      target: o,
+      drag: { filterTaps: !0 }
+    }
+  );
+  const c = C((h) => h.connectionState), g = C((h) => h.updateConnection), p = C((h) => h.endConnection), b = C((h) => h.addEdge);
+  ie(() => {
+    if (!c.isValid) return;
+    const h = (T) => {
+      if (!o.current) return;
+      const I = o.current.getBoundingClientRect();
+      let S = (T.clientX - I.left - a.x) / a.zoom, M = (T.clientY - I.top - a.y) / a.zoom;
+      const x = document.elementFromPoint(T.clientX, T.clientY)?.closest(".ce-handle");
+      if (document.querySelectorAll(".ce-handle--valid").forEach((U) => U.classList.remove("ce-handle--valid")), x && c.nodeId) {
+        const U = x.closest("[data-node-id]")?.getAttribute("data-node-id"), G = x.dataset.handleId, K = x.dataset.handleType, L = c.handleType, F = U === c.nodeId;
+        if (U && G && !F && (L === "source" && K === "target" || L === "target" && K === "source")) {
+          x.classList.add("ce-handle--valid");
+          const te = x.getBoundingClientRect();
+          S = (te.left + te.width / 2 - I.left - a.x) / a.zoom, M = (te.top + te.height / 2 - I.top - a.y) / a.zoom;
+        }
+      }
+      g({ x: S, y: M });
+    }, D = (T) => {
+      const S = document.elementFromPoint(T.clientX, T.clientY)?.closest(".ce-handle");
+      if (S && c.nodeId) {
+        const M = S.closest("[data-node-id]")?.getAttribute("data-node-id"), j = S.dataset.handleId, x = S.dataset.handleType, U = c.handleType, G = M === c.nodeId;
+        if (M && j && !G && (U === "source" && x === "target" || U === "target" && x === "source")) {
+          let L = c.nodeId, F = c.handleId || void 0, ue = M, te = j;
+          U === "target" && x === "source" && (L = M, F = j, ue = c.nodeId, te = c.handleId || void 0), b({
+            id: `e-${Date.now()}`,
+            source: L,
+            sourceHandle: F || void 0,
+            target: ue,
+            targetHandle: te
+          });
+        }
+      }
+      document.querySelectorAll(".ce-handle--valid").forEach((M) => M.classList.remove("ce-handle--valid")), p();
+    };
+    return window.addEventListener("pointermove", h), window.addEventListener("pointerup", D), () => {
+      window.removeEventListener("pointermove", h), window.removeEventListener("pointerup", D), document.querySelectorAll(".ce-handle--valid").forEach((T) => T.classList.remove("ce-handle--valid"));
+    };
+  }, [c.isValid, a, g, p, b, c.nodeId, c.handleType, c.handleId]);
+  const _ = () => {
+    l.viewOnly || v();
+  }, k = l.isLimited ? { touchAction: "none", cursor: O ? "grab" : "default" } : { ...r, touchAction: "none", cursor: O ? "grab" : "default" };
+  return /* @__PURE__ */ y.jsxs(
+    "div",
+    {
+      ref: o,
+      className: `ce-editor__viewport ${O ? "ce-editor__viewport--panning" : ""} ${s} ${l.viewOnly ? "ce-editor--view-only" : ""} ${c.isValid ? "ce-editor--connecting" : ""}`,
+      style: k,
+      onClick: _,
+      children: [
+        n,
+        /* @__PURE__ */ y.jsxs(
+          "div",
+          {
+            className: "ce-editor__canvas",
+            style: {
+              transform: `translate(${a.x}px, ${a.y}px) scale(${a.zoom})`,
+              ...i
+            },
+            children: [
+              l.showGrid && /* @__PURE__ */ y.jsx("div", { className: "ce-editor__grid-layer", children: e || /* @__PURE__ */ y.jsxs("svg", { width: "100%", height: "100%", children: [
+                /* @__PURE__ */ y.jsx("defs", { children: /* @__PURE__ */ y.jsx("pattern", { id: "default-grid", width: l.gridSize, height: l.gridSize, patternUnits: "userSpaceOnUse", children: /* @__PURE__ */ y.jsx("circle", { cx: "1", cy: "1", r: "1", fill: l.gridColor || "#ccc" }) }) }),
+                /* @__PURE__ */ y.jsx("rect", { width: "100%", height: "100%", fill: "url(#default-grid)" })
+              ] }) }),
+              /* @__PURE__ */ y.jsx(hr, {}),
+              l.isLimited ? /* @__PURE__ */ y.jsx(
+                "div",
+                {
+                  className: "ce-editor__content-area",
+                  style: {
+                    width: l.width || 1920,
+                    height: l.height || 1080,
+                    ...r
+                  },
+                  children: t
+                }
+              ) : (
+                // Infinite mode container
+                /* @__PURE__ */ y.jsx("div", { className: "ce-editor__infinite-area", children: t })
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}, pr = {
+  default: ut,
+  input: Gn,
+  output: qn,
+  workflow: ut
+  // Fallback
+}, _r = ({ nodeTypes: t = {} }) => {
+  const e = C((o) => o.nodes), n = C((o) => o.camera), s = C((o) => o.dimensions), r = tt(() => ({ ...pr, ...t }), [t]), i = tt(() => {
+    if (s.width <= 0 || s.height <= 0) return Object.values(e);
+    const o = 100;
+    return Object.values(e).filter((a) => {
+      const l = n.zoom, d = a.x * l + n.x, f = a.y * l + n.y, v = a.width * l, m = a.height * l;
+      return !(d + v < -o || // Left
+      d > s.width + o || // Right
+      f + m < -o || // Top
+      f > s.height + o);
+    });
+  }, [e, n, s]);
+  return /* @__PURE__ */ y.jsx(y.Fragment, { children: i.map((o) => {
+    const a = r[o.type || "default"] || ut;
+    return o.type === "custom" || o.type === "design" || o.resizable || o.rotatable ? /* @__PURE__ */ y.jsx(
+      ur,
+      {
+        id: o.id,
+        draggable: o.draggable,
+        resizable: o.resizable,
+        rotatable: o.rotatable,
+        children: /* @__PURE__ */ y.jsx(a, { style: o.style, className: o.className, data: o.data, id: o.id })
+      },
+      o.id
+    ) : /* @__PURE__ */ y.jsx(
+      fr,
+      {
+        id: o.id,
+        draggable: o.draggable,
+        className: o.className,
+        style: o.style,
+        children: /* @__PURE__ */ y.jsx(a, { data: o.data, id: o.id })
+      },
+      o.id
+    );
+  }) });
+};
+export {
+  yr as Canvas,
+  ut as DefaultNode,
+  gr as Editor,
+  ur as ElementWrapper,
+  Fe as Handle,
+  Gn as InputNode,
+  _r as NodeLayer,
+  qn as OutputNode,
+  fr as WorkflowNodeWrapper,
+  C as useEditor,
+  bt as useEditorStoreApi
+};