f1ow 1.0.0 → 1.1.1

package/dist/f1ow-collaboration.js

@@ -0,0 +1,2603 @@
+var ve = Object.defineProperty;
+var Ie = (t, e, n) => e in t ? ve(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var A = (t, e, n) => Ie(t, typeof e != "symbol" ? e + "" : e, n);
+import * as R from "yjs";
+import { WebsocketProvider as re } from "y-websocket";
+import { create as _e } from "zustand";
+import Se, { useState as Tt, useRef as tt, useEffect as Ae, useCallback as ht, useMemo as Ee } from "react";
+import { jsx as G, Fragment as ke, jsxs as Ot } from "react/jsx-runtime";
+import { Group as Pt, Rect as Bt, Line as Te, Text as Oe } from "react-konva";
+let D = null, E = null, St = null, pt = /* @__PURE__ */ new Set();
+function Pe(t) {
+  return E && ie(), St = t, D = new R.Doc(), E = new re(
+    t.serverUrl,
+    t.roomName,
+    D,
+    {
+      connect: !0,
+      params: t.authToken ? { token: t.authToken } : void 0
+    }
+  ), E.awareness.setLocalState({
+    user: t.user,
+    cursor: null,
+    selectedIds: []
+  }), E.on("status", (e) => {
+    const n = e.status;
+    for (const s of pt)
+      s(n);
+  }), { doc: D, provider: E };
+}
+function ie() {
+  E && (E.awareness.setLocalState(null), E.disconnect(), E.destroy(), E = null), D && (D.destroy(), D = null), St = null;
+}
+function oe() {
+  return D;
+}
+function Be() {
+  return E;
+}
+function ce() {
+  return D?.getMap("elements");
+}
+function Re() {
+  return St;
+}
+function Ce() {
+  return E !== null && E.wsconnected;
+}
+function Ye(t) {
+  return pt.add(t), () => {
+    pt.delete(t);
+  };
+}
+function Le(t) {
+  if (!E) return;
+  const e = E.awareness.getLocalState();
+  E.awareness.setLocalState({
+    ...e,
+    ...t
+  });
+}
+function Xe() {
+  if (!E) return /* @__PURE__ */ new Map();
+  const t = E.awareness.getStates(), e = E.awareness.clientID, n = /* @__PURE__ */ new Map();
+  for (const [s, r] of t)
+    s !== e && r && r.user && n.set(s, r);
+  return n;
+}
+const Me = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createCollaborationProvider: Pe,
+  destroyCollaborationProvider: ie,
+  getCollaborationConfig: Re,
+  getRemoteAwareness: Xe,
+  getYDoc: oe,
+  getYElements: ce,
+  getYProvider: Be,
+  isCollaborationActive: Ce,
+  onStatusChange: Ye,
+  updateAwareness: Le
+}, Symbol.toStringTag, { value: "Module" })), De = {
+  strokeColor: "#1e1e1e",
+  fillColor: "transparent",
+  strokeWidth: 2,
+  opacity: 1,
+  strokeStyle: "solid",
+  roughness: 0,
+  fontSize: 20,
+  fontFamily: "system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, sans-serif",
+  freehandStyle: "standard"
+}, At = 0.1, Et = 5, ae = 20, le = 25, de = 36, J = 40, Rt = 1e4, mt = 24, Ne = 1.5;
+function dt(t) {
+  switch (t) {
+    case "up":
+      return { x: 0, y: -1 };
+    case "down":
+      return { x: 0, y: 1 };
+    case "left":
+      return { x: -1, y: 0 };
+    case "right":
+      return { x: 1, y: 0 };
+  }
+}
+function q(t) {
+  return t === "up" || t === "down";
+}
+function fe(t) {
+  return t >= 0 ? "right" : "left";
+}
+function ue(t) {
+  return t >= 0 ? "down" : "up";
+}
+function Fe(t, e, n) {
+  return q(t) ? fe(e) : ue(n);
+}
+function Ct(t, e, n, s) {
+  const r = t.x + t.width / 2, i = t.y + t.height / 2, o = e.x - r, c = e.y - i, a = fe(o), l = ue(c);
+  if (n) {
+    const g = t.x + t.width, p = t.y + t.height, x = n.x + n.width, w = n.y + n.height, b = g < n.x ? n.x - g : x < t.x ? t.x - x : 0, I = p < n.y ? n.y - p : w < t.y ? t.y - w : 0;
+    if (!!(s?.isPrecise && !(s.fixedPoint[0] === 0.5 && s.fixedPoint[1] === 0.5)) && b > 0 && I > 0) {
+      const _ = xt(s.fixedPoint);
+      return _ === "left" || _ === "right" ? { primary: a } : { primary: l };
+    }
+    if (b > 0 && I === 0)
+      return { primary: a };
+    if (I > 0 && b === 0)
+      return { primary: l };
+    if (b > 0 && I > 0) {
+      const _ = b < I ? a : l, S = Fe(_, o, c);
+      return Math.abs(b - I) <= mt ? { primary: _, alternate: S } : { primary: _ };
+    }
+    const y = Math.max(0, Math.min(g, x) - Math.max(t.x, n.x)), v = Math.max(0, Math.min(p, w) - Math.max(t.y, n.y));
+    if (y > v)
+      return Math.abs(y - v) <= mt ? { primary: l, alternate: a } : { primary: l };
+    if (v > y)
+      return Math.abs(v - y) <= mt ? { primary: a, alternate: l } : { primary: a };
+  }
+  const f = (t.width || 1) / 2, u = (t.height || 1) / 2, d = Math.abs(o) / f, m = Math.abs(c) / u;
+  return d > m * 3 ? { primary: a } : m > d * 3 ? { primary: l } : Math.max(d, m) / Math.max(1e-6, Math.min(d, m)) <= Ne ? { primary: l, alternate: a } : { primary: l };
+}
+function xt(t) {
+  const [e, n] = t, s = n, r = 1 - n, i = e, o = 1 - e, c = Math.min(s, r, i, o);
+  return c === s ? "up" : c === r ? "down" : c === i ? "left" : "right";
+}
+function Yt(t, e) {
+  const n = e.x - t.x, s = e.y - t.y;
+  return Math.abs(n) >= Math.abs(s) ? n >= 0 ? "right" : "left" : s >= 0 ? "down" : "up";
+}
+function Lt(t, e) {
+  const n = t.x + t.width / 2, s = t.y + t.height / 2, r = e.x - n, i = e.y - s, o = t.width / 2 || 1, c = t.height / 2 || 1, a = r / o, l = i / c;
+  return Math.abs(a) >= Math.abs(l) ? r >= 0 ? "right" : "left" : i >= 0 ? "down" : "up";
+}
+function k(t) {
+  return t.left + t.width;
+}
+function T(t) {
+  return t.top + t.height;
+}
+function $e(t, e) {
+  return e.x > t.left && e.x < k(t) && e.y > t.top && e.y < T(t);
+}
+function L(t, e, n) {
+  return {
+    left: t.left - e,
+    top: t.top - n,
+    width: t.width + e * 2,
+    height: t.height + n * 2
+  };
+}
+function et(t, e, n) {
+  const s = Math.min(e, le), r = n === "left" ? s : e, i = n === "right" ? s : e, o = n === "up" ? s : e, c = n === "down" ? s : e;
+  return {
+    left: t.left - r,
+    top: t.top - o,
+    width: t.width + r + i,
+    height: t.height + o + c
+  };
+}
+function Xt(t, e, n) {
+  const s = new Set(n), r = Math.min(e, le), i = s.has("left") ? r : e, o = s.has("right") ? r : e, c = s.has("up") ? r : e, a = s.has("down") ? r : e;
+  return {
+    left: t.left - i,
+    top: t.top - c,
+    width: t.width + i + o,
+    height: t.height + c + a
+  };
+}
+function Ue(t, e) {
+  const n = Math.min(t.left, e.left), s = Math.min(t.top, e.top), r = Math.max(k(t), k(e)), i = Math.max(T(t), T(e));
+  return { left: n, top: s, width: r - n, height: i - s };
+}
+function K(t) {
+  return { left: t.x, top: t.y, width: t.width, height: t.height };
+}
+function He(t) {
+  const e = t.rotation || 0;
+  if (e === 0)
+    return { x: t.x, y: t.y, width: t.width, height: t.height };
+  const n = t.x + t.width / 2, s = t.y + t.height / 2, r = t.width / 2, i = t.height / 2, o = e * Math.PI / 180, c = Math.cos(o), a = Math.sin(o), l = [
+    { x: -r, y: -i },
+    { x: r, y: -i },
+    { x: r, y: i },
+    { x: -r, y: i }
+  ].map((h) => ({
+    x: n + h.x * c - h.y * a,
+    y: s + h.x * a + h.y * c
+  }));
+  let f = 1 / 0, u = 1 / 0, d = -1 / 0, m = -1 / 0;
+  for (const h of l)
+    h.x < f && (f = h.x), h.y < u && (u = h.y), h.x > d && (d = h.x), h.y > m && (m = h.y);
+  return { x: f, y: u, width: d - f, height: m - u };
+}
+function Je(t) {
+  switch (t) {
+    case "left":
+      return "right";
+    case "right":
+      return "left";
+    case "up":
+      return "down";
+    case "down":
+      return "up";
+  }
+}
+function je(t, e) {
+  return e.x < t.x ? "left" : e.x > t.x ? "right" : e.y < t.y ? "up" : e.y > t.y ? "down" : null;
+}
+function We(t, e) {
+  return t === null || e === null ? !1 : (t === "left" || t === "right" ? "h" : "v") !== (e === "left" || e === "right" ? "h" : "v");
+}
+class ze {
+  constructor(e) {
+    A(this, "adjacent", /* @__PURE__ */ new Map());
+    this.pt = e;
+  }
+}
+class Ge {
+  constructor() {
+    A(this, "idx", {});
+  }
+  add(e) {
+    const n = String(e.x), s = String(e.y);
+    n in this.idx || (this.idx[n] = {}), s in this.idx[n] || (this.idx[n][s] = new ze(e));
+  }
+  get(e) {
+    const n = String(e.x), s = String(e.y);
+    return this.idx[n]?.[s] ?? null;
+  }
+  has(e) {
+    return this.get(e) !== null;
+  }
+  /** Create a bidirectional edge between two points */
+  connect(e, n) {
+    const s = this.get(e), r = this.get(n);
+    if (!s || !r) return;
+    const i = Math.abs(n.x - e.x) + Math.abs(n.y - e.y);
+    s.adjacent.set(r, i), r.adjacent.set(s, i);
+  }
+}
+class Ve {
+  constructor() {
+    A(this, "data", []);
+  }
+  get size() {
+    return this.data.length;
+  }
+  push(e, n) {
+    this.data.push({ item: e, priority: n }), this.bubbleUp(this.data.length - 1);
+  }
+  pop() {
+    if (this.data.length === 0) return;
+    const e = this.data[0], n = this.data.pop();
+    return this.data.length > 0 && (this.data[0] = n, this.sinkDown(0)), e.item;
+  }
+  bubbleUp(e) {
+    for (; e > 0; ) {
+      const n = e - 1 >> 1;
+      if (this.data[n].priority <= this.data[e].priority) break;
+      [this.data[n], this.data[e]] = [this.data[e], this.data[n]], e = n;
+    }
+  }
+  sinkDown(e) {
+    const n = this.data.length;
+    for (; ; ) {
+      let s = e;
+      const r = 2 * e + 1, i = 2 * e + 2;
+      if (r < n && this.data[r].priority < this.data[s].priority && (s = r), i < n && this.data[i].priority < this.data[s].priority && (s = i), s === e) break;
+      [this.data[s], this.data[e]] = [this.data[e], this.data[s]], e = s;
+    }
+  }
+}
+function Ze(t, e, n) {
+  const s = t.get(e), r = t.get(n);
+  if (!s || !r) return null;
+  const i = (d) => Math.abs(d.x - n.x) + Math.abs(d.y - n.y), o = (d, m) => `${d.pt.x},${d.pt.y},${m ?? "n"}`, c = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), l = new Ve(), f = { node: s, dir: null, g: 0 }, u = o(s, null);
+  for (c.set(u, 0), a.set(u, null), l.push(f, i(s.pt)); l.size > 0; ) {
+    const d = l.pop(), m = o(d.node, d.dir);
+    if (!(d.g > (c.get(m) ?? 1 / 0))) {
+      if (d.node === r) {
+        const h = [];
+        let g = d;
+        for (; g; ) {
+          h.push(g.node.pt);
+          const p = o(g.node, g.dir);
+          if (g = a.get(p), g == null) break;
+        }
+        return h[h.length - 1] !== s.pt && h.push(s.pt), h.reverse(), h;
+      }
+      for (const [h, g] of d.node.adjacent) {
+        const p = je(d.node.pt, h.pt);
+        if (p === null) continue;
+        const x = d.dir !== null && p === Je(d.dir), w = We(d.dir, p), b = x ? Rt * 3 : w ? Rt : 0, I = d.g + g + b, O = o(h, p);
+        I < (c.get(O) ?? 1 / 0) && (c.set(O, I), a.set(O, d), l.push(
+          { node: h, dir: p, g: I },
+          I + i(h.pt)
+        ));
+      }
+    }
+  }
+  return null;
+}
+function qe(t) {
+  const e = /* @__PURE__ */ new Map(), n = [];
+  for (const s of t) {
+    let r = e.get(s.x);
+    r || (r = /* @__PURE__ */ new Set(), e.set(s.x, r)), r.has(s.y) || (r.add(s.y), n.push(s));
+  }
+  return n;
+}
+function Ke(t, e, n, s) {
+  const r = n.left, i = k(n), o = n.top, c = T(n), a = [.../* @__PURE__ */ new Set([r, ...t.filter((d) => d >= r && d <= i), i])].sort((d, m) => d - m), l = [.../* @__PURE__ */ new Set([o, ...e.filter((d) => d >= o && d <= c), c])].sort((d, m) => d - m), f = (d) => s.some((m) => $e(m, d)), u = [];
+  for (const d of l)
+    for (const m of a) {
+      const h = { x: m, y: d };
+      f(h) || u.push(h);
+    }
+  return u;
+}
+function Mt(t, e, n) {
+  if (t.y === e.y) {
+    const s = t.y, r = Math.min(t.x, e.x), i = Math.max(t.x, e.x);
+    for (const o of n)
+      if (o.top < s && s < T(o) && o.left < i && k(o) > r)
+        return !0;
+  } else if (t.x === e.x) {
+    const s = t.x, r = Math.min(t.y, e.y), i = Math.max(t.y, e.y);
+    for (const o of n)
+      if (o.left < s && s < k(o) && o.top < i && T(o) > r)
+        return !0;
+  }
+  return !1;
+}
+function Qe(t, e) {
+  const n = new Ge(), s = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+  for (const c of t)
+    n.add(c), s.add(c.x), r.add(c.y);
+  const i = [...s].sort((c, a) => c - a), o = [...r].sort((c, a) => c - a);
+  for (let c = 0; c < o.length; c++)
+    for (let a = 0; a < i.length; a++) {
+      const l = { x: i[a], y: o[c] };
+      if (n.has(l)) {
+        for (let f = a - 1; f >= 0; f--) {
+          const u = { x: i[f], y: o[c] };
+          if (n.has(u)) {
+            Mt(u, l, e) || n.connect(u, l);
+            break;
+          }
+        }
+        for (let f = c - 1; f >= 0; f--) {
+          const u = { x: i[a], y: o[f] };
+          if (n.has(u)) {
+            Mt(u, l, e) || n.connect(u, l);
+            break;
+          }
+        }
+      }
+    }
+  return n;
+}
+function he(t) {
+  if (t.length <= 2) return t;
+  const e = [t[0]];
+  for (let n = 1; n < t.length - 1; n++) {
+    const s = t[n - 1], r = t[n], i = t[n + 1], o = s.x === r.x && r.x === i.x, c = s.y === r.y && r.y === i.y;
+    o || c || s.x === r.x && s.y === r.y || e.push(r);
+  }
+  return e.push(t[t.length - 1]), e;
+}
+function wt(t) {
+  if (t.length <= 2) return 0;
+  let e = 0;
+  for (let n = 1; n < t.length - 1; n++) {
+    const s = t[n - 1], r = t[n], i = t[n + 1], o = s.x === r.x && r.x === i.x, c = s.y === r.y && r.y === i.y;
+    !o && !c && e++;
+  }
+  return e;
+}
+function bt(t) {
+  let e = 0;
+  for (let n = 1; n < t.length; n++)
+    e += Math.abs(t[n].x - t[n - 1].x) + Math.abs(t[n].y - t[n - 1].y);
+  return e;
+}
+function tn(t) {
+  let e = t[0], n = wt(e), s = bt(e);
+  for (let r = 1; r < t.length; r++) {
+    const i = wt(t[r]), o = bt(t[r]);
+    (i < n || i === n && o < s) && (e = t[r], n = i, s = o);
+  }
+  return e;
+}
+function en(t, e) {
+  return Math.abs(e.x - t.x) + Math.abs(e.y - t.y);
+}
+function nn(t) {
+  if (t.length <= 3) return 0;
+  const e = de * 0.75;
+  let n = 0;
+  for (let s = 1; s < t.length - 2; s++) {
+    const r = en(t[s], t[s + 1]);
+    r < e && (n += e - r);
+  }
+  return n;
+}
+function sn(t, e, n) {
+  if (t.x === e.x) {
+    const a = t.x, l = Math.min(t.y, e.y), f = Math.max(t.y, e.y), u = a < n.left ? n.left - a : a > k(n) ? a - k(n) : 0, d = f < n.top ? n.top - f : l > T(n) ? l - T(n) : 0;
+    return Math.hypot(u, d);
+  }
+  const s = t.y, r = Math.min(t.x, e.x), i = Math.max(t.x, e.x), o = s < n.top ? n.top - s : s > T(n) ? s - T(n) : 0, c = i < n.left ? n.left - i : r > k(n) ? r - k(n) : 0;
+  return Math.hypot(c, o);
+}
+function rn(t, e) {
+  if (t.length <= 3 || e.length === 0) return Number.POSITIVE_INFINITY;
+  const n = e.map(K);
+  let s = Number.POSITIVE_INFINITY;
+  for (let r = 1; r < t.length - 2; r++)
+    for (const i of n)
+      s = Math.min(s, sn(t[r], t[r + 1], i));
+  return s;
+}
+function on(t, e) {
+  const n = t.alternate ? [t.primary, t.alternate] : [t.primary], s = e.alternate ? [e.primary, e.alternate] : [e.primary], r = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n.length; i++)
+    for (let o = 0; o < s.length; o++) {
+      const c = {
+        startDir: n[i],
+        endDir: s[o],
+        preferencePenalty: i + o
+      }, a = `${c.startDir}|${c.endDir}`, l = r.get(a);
+      (!l || c.preferencePenalty < l.preferencePenalty) && r.set(a, c);
+    }
+  return [...r.values()].sort((i, o) => i.preferencePenalty - o.preferencePenalty);
+}
+function cn(t, e) {
+  return t.bends !== e.bends ? t.bends < e.bends : Math.abs(t.shortSegmentPenalty - e.shortSegmentPenalty) > 0.5 ? t.shortSegmentPenalty < e.shortSegmentPenalty : Math.abs(t.clearance - e.clearance) > 1 ? t.clearance > e.clearance : Math.abs(t.length - e.length) > 0.5 ? t.length < e.length : t.preferencePenalty < e.preferencePenalty;
+}
+function an(t) {
+  const {
+    startWorld: e,
+    endWorld: n,
+    startBinding: s,
+    endBinding: r,
+    startShape: i,
+    endShape: o,
+    intermediateObstacles: c = [],
+    minStubLength: a
+  } = t, l = (g) => !g.isPrecise || g.fixedPoint[0] === 0.5 && g.fixedPoint[1] === 0.5, f = s && l(s) ? Ct(i ?? { x: e.x, y: e.y, width: 1, height: 1 }, n, o, r) : { primary: s ? xt(s.fixedPoint) : Yt(e, n) }, u = r && l(r) ? Ct(o ?? { x: n.x, y: n.y, width: 1, height: 1 }, e, i, s) : { primary: r ? xt(r.fixedPoint) : Yt(n, e) }, d = on(f, u);
+  if (d.length === 1)
+    return { startDir: d[0].startDir, endDir: d[0].endDir };
+  const m = [
+    ...i ? [i] : [],
+    ...o ? [o] : [],
+    ...c
+  ];
+  let h = null;
+  for (const g of d) {
+    const p = ln(
+      e,
+      n,
+      g.startDir,
+      g.endDir,
+      i,
+      o,
+      a,
+      c
+    ), x = {
+      ...g,
+      path: p,
+      bends: wt(p),
+      length: bt(p),
+      shortSegmentPenalty: nn(p),
+      clearance: rn(p, m)
+    };
+    (!h || cn(x, h)) && (h = x);
+  }
+  return h ? { startDir: h.startDir, endDir: h.endDir } : { startDir: f.primary, endDir: u.primary };
+}
+function nt(t, e, n, s, r, i) {
+  let o = {
+    left: Math.min(t.x, e.x),
+    top: Math.min(t.y, e.y),
+    width: Math.abs(e.x - t.x) || 1,
+    height: Math.abs(e.y - t.y) || 1
+  };
+  for (const x of r)
+    o = Ue(o, x);
+  o = L(o, J, J);
+  const c = [], a = [];
+  for (const x of r)
+    c.push(x.left, k(x)), a.push(x.top, T(x)), c.push(x.left + x.width / 2), a.push(x.top + x.height / 2);
+  c.push(t.x, e.x), a.push(t.y, e.y);
+  const l = dt(n), f = dt(s);
+  let u = {
+    x: t.x + l.x * i,
+    y: t.y + l.y * i
+  }, d = {
+    x: e.x + f.x * i,
+    y: e.y + f.y * i
+  };
+  u = Dt(u, n, r), d = Dt(d, s, r), c.push(u.x, d.x), a.push(u.y, d.y), c.push((t.x + e.x) / 2), a.push((t.y + e.y) / 2);
+  const m = Ke(c, a, o, r), h = qe([u, d, ...m]), g = Qe(h, r), p = Ze(g, u, d);
+  if (p) {
+    const x = [t, ...p, e];
+    return he(x);
+  }
+  return null;
+}
+function ln(t, e, n, s, r, i, o, c) {
+  if (t.x === e.x && t.y === e.y)
+    return [t, e];
+  const a = r ? K(r) : { left: t.x, top: t.y, width: 0, height: 0 }, l = i ? K(i) : { left: e.x, top: e.y, width: 0, height: 0 }, f = ae, u = Math.max(de, o ?? 0), d = (c ?? []).map(
+    (y) => L(K(y), f, f)
+  ), m = r ? et(a, f, n) : L(a, f, f), h = i ? et(l, f, s) : L(l, f, f), g = [n], p = [s];
+  let x = !1;
+  if (r) {
+    const y = Lt(r, e);
+    y !== n && (g.push(y), x = !0);
+  }
+  if (i) {
+    const y = Lt(i, t);
+    y !== s && (p.push(y), x = !0);
+  }
+  const w = r ? Xt(a, f, g) : L(a, f, f), b = i ? Xt(l, f, p) : L(l, f, f), I = [], O = nt(
+    t,
+    e,
+    n,
+    s,
+    [m, h, ...d],
+    u
+  );
+  if (O && I.push(O), x) {
+    const y = nt(
+      t,
+      e,
+      n,
+      s,
+      [w, b, ...d],
+      u
+    );
+    y && I.push(y);
+  }
+  if (I.length > 0)
+    return tn(I);
+  if (d.length > 0) {
+    const y = nt(
+      t,
+      e,
+      n,
+      s,
+      [m, h],
+      u
+    );
+    if (y) return y;
+  }
+  if (d.length > 0) {
+    const y = Math.max(4, f / 2), v = (c ?? []).map(
+      ($) => L(K($), y, y)
+    ), _ = r ? et(a, y, n) : L(a, y, y), S = i ? et(l, y, s) : L(l, y, y), B = nt(
+      t,
+      e,
+      n,
+      s,
+      [_, S, ...v],
+      u
+    );
+    if (B)
+      return B;
+  }
+  return he(dn(t, e, n, s, u));
+}
+function Dt(t, e, n) {
+  let { x: s, y: r } = t;
+  for (let i = 0; i < n.length; i++) {
+    let o = !0;
+    for (const c of n)
+      if (!(s <= c.left || s >= k(c) || r <= c.top || r >= T(c)))
+        switch (o = !1, e) {
+          case "left":
+            s = c.left - 1;
+            break;
+          case "right":
+            s = k(c) + 1;
+            break;
+          case "up":
+            r = c.top - 1;
+            break;
+          case "down":
+            r = T(c) + 1;
+            break;
+        }
+    if (o) break;
+  }
+  return { x: s, y: r };
+}
+function dn(t, e, n, s, r) {
+  const i = Math.max(r, ae), o = dt(n), c = dt(s), a = { x: t.x + o.x * i, y: t.y + o.y * i }, l = { x: e.x + c.x * i, y: e.y + c.y * i };
+  if (q(n) === q(s))
+    if (q(n)) {
+      const f = (a.y + l.y) / 2;
+      return [t, a, { x: a.x, y: f }, { x: l.x, y: f }, l, e];
+    } else {
+      const f = (a.x + l.x) / 2;
+      return [t, a, { x: f, y: a.y }, { x: f, y: l.y }, l, e];
+    }
+  else
+    return q(n) ? [t, a, { x: a.x, y: l.y }, l, e] : [t, a, { x: l.x, y: a.y }, l, e];
+}
+const fn = /* @__PURE__ */ new Set(["rectangle", "ellipse", "diamond", "text", "image"]);
+function un(t, e, n, s) {
+  const r = [], i = Math.min(t.x, e.x) - J * 3, o = Math.max(t.x, e.x) + J * 3, c = Math.min(t.y, e.y) - J * 3, a = Math.max(t.y, e.y) + J * 3;
+  for (const l of n) {
+    if (!fn.has(l.type) || s.has(l.id) || !l.isVisible) continue;
+    const f = He(l);
+    f.x + f.width < i || f.x > o || f.y + f.height < c || f.y > a || r.push(f);
+  }
+  return r;
+}
+const me = 0.2;
+function hn(t, e, n = me) {
+  const s = (t.x + e.x) / 2, r = (t.y + e.y) / 2, i = e.x - t.x, o = e.y - t.y, c = Math.sqrt(i * i + o * o);
+  if (c === 0) return { x: s, y: r };
+  const a = -o / c, l = i / c, f = c * n;
+  return { x: s + a * f, y: r + l * f };
+}
+function mn(t, e, n, s) {
+  const r = 1 - s;
+  return {
+    x: r * r * t.x + 2 * r * s * e.x + s * s * n.x,
+    y: r * r * t.y + 2 * r * s * e.y + s * s * n.y
+  };
+}
+function ye(t) {
+  return t * Math.PI / 180;
+}
+function ge(t, e, n) {
+  if (n === 0) return { x: t, y: e };
+  const s = Math.cos(n), r = Math.sin(n);
+  return { x: t * s - e * r, y: t * r + e * s };
+}
+function yn(t, e) {
+  const n = t.x + t.width / 2, s = t.y + t.height / 2, r = e.x - n, i = e.y - s, o = ye(t.rotation || 0);
+  return o === 0 ? { x: r, y: i } : ge(r, i, -o);
+}
+function Q(t, e) {
+  const n = t.x + t.width / 2, s = t.y + t.height / 2, r = ye(t.rotation || 0), i = ge(e.x, e.y, r);
+  return { x: n + i.x, y: s + i.y };
+}
+function gn(t) {
+  switch (t) {
+    case "n":
+      return [0.5, 0];
+    case "s":
+      return [0.5, 1];
+    case "e":
+      return [1, 0.5];
+    case "w":
+      return [0, 0.5];
+    case "ne":
+      return [1, 0];
+    case "nw":
+      return [0, 0];
+    case "se":
+      return [1, 1];
+    case "sw":
+      return [0, 1];
+    case "center":
+      return [0.5, 0.5];
+    case "auto":
+      return [0.5, 0.5];
+    // caller should resolve via nearest
+    default:
+      return [0.5, 0.5];
+  }
+}
+function pn(t, e) {
+  if (!t.ports) return null;
+  const n = t.ports.find((s) => s.id === e);
+  return n ? n.ratio : null;
+}
+function Nt(t, e) {
+  if (t.portId) {
+    const s = pn(e, t.portId);
+    if (s) return { fixedPoint: s, snapMode: "port" };
+  }
+  if (t.anchor && t.anchor !== "auto")
+    return { fixedPoint: gn(t.anchor), snapMode: "anchor" };
+  const n = t.fixedPoint[0] === 0.5 && t.fixedPoint[1] === 0.5 ? "center" : "edge";
+  return { fixedPoint: t.fixedPoint, snapMode: n };
+}
+function Ft(t, e, n = 0, s) {
+  const r = (e[0] - 0.5) * t.width, i = (e[1] - 0.5) * t.height;
+  if (r === 0 && i === 0)
+    return s ? ft(t, s, n) : Q(t, { x: 0, y: 0 });
+  const o = Q(t, { x: r, y: i });
+  return ft(t, o, n);
+}
+function ft(t, e, n = 0) {
+  const s = yn(t, e), r = s.x, i = s.y;
+  if (r === 0 && i === 0)
+    return t.width >= t.height ? Q(t, { x: t.width / 2 + n, y: 0 }) : Q(t, { x: 0, y: -(t.height / 2 + n) });
+  let o;
+  switch (t.type) {
+    case "ellipse": {
+      const c = t.width / 2, a = t.height / 2, l = Math.atan2(i, r);
+      o = {
+        x: (c + n) * Math.cos(l),
+        y: (a + n) * Math.sin(l)
+      };
+      break;
+    }
+    case "diamond": {
+      const c = t.width / 2, a = t.height / 2, l = Math.atan2(i, r), f = Math.cos(l), u = Math.sin(l), d = Math.abs(f), m = Math.abs(u), h = 1 / (d / c + m / a), g = h * f, p = h * u;
+      if (n === 0)
+        o = { x: g, y: p };
+      else {
+        const x = (f >= 0 ? 1 : -1) / c, w = (u >= 0 ? 1 : -1) / a, b = Math.sqrt(x * x + w * w);
+        o = {
+          x: g + x / b * n,
+          y: p + w / b * n
+        };
+      }
+      break;
+    }
+    default: {
+      const c = t.width / 2, a = t.height / 2, l = Math.atan2(i, r), f = Math.abs(Math.tan(l));
+      let u, d;
+      f <= a / c ? (u = r > 0 ? c : -c, d = u * Math.tan(l)) : (d = i > 0 ? a : -a, u = d / Math.tan(l)), n === 0 ? o = { x: u, y: d } : f <= a / c ? o = { x: u + (r > 0 ? n : -n), y: d } : o = { x: u, y: d + (i > 0 ? n : -n) };
+      break;
+    }
+  }
+  return Q(t, o);
+}
+function xn(t, e) {
+  const { startBinding: n, endBinding: s } = t;
+  if (!n && !s) return null;
+  const r = new Map(e.map((y) => [y.id, y])), i = t.points, o = i.length / 2;
+  let c = {
+    x: t.x + i[0],
+    y: t.y + i[1]
+  }, a = {
+    x: t.x + i[i.length - 2],
+    y: t.y + i[i.length - 1]
+  };
+  const l = n ? r.get(n.elementId) : void 0, f = s ? r.get(s.elementId) : void 0, u = t.lineType === "elbow", d = (y, v) => {
+    if (y.isPrecise) {
+      const { fixedPoint: _ } = Nt(y, v);
+      return Ft(v, _, 0);
+    }
+    return { x: v.x + v.width / 2, y: v.y + v.height / 2 };
+  }, m = (y, v, _) => {
+    const { fixedPoint: S } = Nt(y, v);
+    return Ft(v, S, y.gap, _);
+  }, h = n && l ? n.isPrecise ? m(n, l, a) : { x: l.x + l.width / 2, y: l.y + l.height / 2 } : c, g = s && f ? s.isPrecise ? m(s, f, c) : { x: f.x + f.width / 2, y: f.y + f.height / 2 } : a, p = u ? (() => {
+    const y = /* @__PURE__ */ new Set();
+    return n?.elementId && y.add(n.elementId), s?.elementId && y.add(s.elementId), an({
+      startWorld: h,
+      endWorld: g,
+      startBinding: n,
+      endBinding: s,
+      startShape: l ?? null,
+      endShape: f ?? null,
+      intermediateObstacles: un(h, g, e, y)
+    });
+  })() : null, x = (y, v, _) => {
+    const S = y.x + y.width / 2, B = y.y + y.height / 2, $ = Math.max(y.width, y.height) * 10;
+    let z;
+    switch (_) {
+      case "up":
+        z = { x: S, y: B - $ };
+        break;
+      case "down":
+        z = { x: S, y: B + $ };
+        break;
+      case "left":
+        z = { x: S - $, y: B };
+        break;
+      case "right":
+        z = { x: S + $, y: B };
+        break;
+    }
+    return ft(y, z, v);
+  }, w = u ? (y, v, _, S) => x(y, _, S) : ft;
+  if (n && l && s && f) {
+    if (n.isPrecise)
+      c = m(n, l, a);
+    else {
+      const y = d(s, f);
+      c = w(l, y, n.gap, p?.startDir ?? "right");
+    }
+    if (s.isPrecise)
+      a = m(s, f, c);
+    else {
+      const y = d(n, l);
+      a = w(f, y, s.gap, p?.endDir ?? "left");
+    }
+    n.isPrecise ? c = m(n, l, a) : n.isPrecise || (c = w(l, a, n.gap, p?.startDir ?? "right")), s.isPrecise ? a = m(s, f, c) : s.isPrecise || (a = w(f, c, s.gap, p?.endDir ?? "left"));
+  } else
+    n && l && (n.isPrecise ? c = m(n, l, a) : c = w(l, a, n.gap, p?.startDir ?? "right")), s && f && (s.isPrecise ? a = m(s, f, c) : a = w(f, c, s.gap, p?.endDir ?? "left"));
+  const b = [0, 0];
+  for (let y = 1; y < o - 1; y++) {
+    const v = t.x + i[y * 2], _ = t.y + i[y * 2 + 1];
+    b.push(v - c.x, _ - c.y);
+  }
+  b.push(a.x - c.x, a.y - c.y);
+  const I = a.x - c.x, O = a.y - c.y;
+  return {
+    x: c.x,
+    y: c.y,
+    points: b,
+    width: Math.abs(I),
+    height: Math.abs(O)
+  };
+}
+function wn(t, e) {
+  return e.filter((n) => {
+    if (n.type !== "line" && n.type !== "arrow") return !1;
+    const s = n;
+    return s.startBinding?.elementId === t || s.endBinding?.elementId === t;
+  });
+}
+function bn(t, e) {
+  return e.map((n) => {
+    let s = !1;
+    if (n.boundElements && n.boundElements.length > 0) {
+      const c = n.boundElements.filter((a) => !t.has(a.id));
+      c.length !== n.boundElements.length && (n = { ...n, boundElements: c.length > 0 ? c : null }, s = !0);
+    }
+    if (n.type !== "line" && n.type !== "arrow") return n;
+    const r = n;
+    let i = r.startBinding, o = r.endBinding;
+    return i && t.has(i.elementId) && (i = null, s = !0), o && t.has(o.elementId) && (o = null, s = !0), s ? { ...n, startBinding: i, endBinding: o } : n;
+  });
+}
+function vn(t, e, n) {
+  const s = t.points, r = { x: s[0], y: s[1] }, i = { x: s[s.length - 2], y: s[s.length - 1] };
+  let o, c;
+  if (t.lineType === "curved") {
+    const a = t.curvature ?? me, l = hn(r, i, a), f = mn(r, l, i, 0.5);
+    o = t.x + f.x, c = t.y + f.y;
+  } else if (t.lineType === "elbow" && s.length >= 4) {
+    const a = s.length / 2 - 1;
+    let l = 0;
+    for (let d = 0; d < a; d++) {
+      const m = s[(d + 1) * 2] - s[d * 2], h = s[(d + 1) * 2 + 1] - s[d * 2 + 1];
+      l += Math.sqrt(m * m + h * h);
+    }
+    const f = l / 2;
+    let u = 0;
+    o = t.x + (r.x + i.x) / 2, c = t.y + (r.y + i.y) / 2;
+    for (let d = 0; d < a; d++) {
+      const m = s[d * 2], h = s[d * 2 + 1], g = s[(d + 1) * 2], p = s[(d + 1) * 2 + 1], x = g - m, w = p - h, b = Math.sqrt(x * x + w * w);
+      if (u + b >= f && b > 0) {
+        const I = (f - u) / b;
+        o = t.x + m + x * I, c = t.y + h + w * I;
+        break;
+      }
+      u += b;
+    }
+  } else
+    o = t.x + (r.x + i.x) / 2, c = t.y + (r.y + i.y) / 2;
+  return {
+    x: o - e / 2,
+    y: c - n / 2
+  };
+}
+function In(t, e) {
+  const n = [];
+  for (const s of t) {
+    const r = e.get(s);
+    if (!r || r.type !== "arrow" && r.type !== "line" || !r.boundElements) continue;
+    const i = r;
+    for (const o of r.boundElements) {
+      if (o.type !== "text") continue;
+      const c = e.get(o.id);
+      if (!c) continue;
+      const a = Math.max(10, c.width || 60), l = c.height || 30, f = vn(i, a, l);
+      n.push({ id: c.id, updates: { x: f.x, y: f.y } });
+    }
+  }
+  return n;
+}
+const st = 4, _n = /* @__PURE__ */ new Set([
+  "rectangle",
+  "ellipse",
+  "diamond",
+  "image"
+]);
+function Sn(t, e) {
+  const n = Math.max(20, t.width - st * 2);
+  let s;
+  return e.verticalAlign === "top" ? s = t.y + st : e.verticalAlign === "bottom" ? s = t.y + t.height - e.height - st : s = t.y + (t.height - e.height) / 2, { x: t.x + st, y: s, width: n };
+}
+function An(t, e, n) {
+  const s = /* @__PURE__ */ new Map();
+  for (const o of e) s.set(o.id, o);
+  const r = [], i = /* @__PURE__ */ new Set();
+  for (const o of t) {
+    const c = wn(o, e);
+    for (const l of c) {
+      if (i.has(l.id)) continue;
+      i.add(l.id);
+      const f = s.get(l.id);
+      if (!f) continue;
+      const u = xn(f, e);
+      u && r.push({ id: f.id, updates: u });
+    }
+    const a = s.get(o);
+    if (a?.boundElements && _n.has(a.type))
+      for (const l of a.boundElements) {
+        if (l.type !== "text") continue;
+        const f = s.get(l.id);
+        f && r.push({ id: l.id, updates: Sn(a, f) });
+      }
+  }
+  if (i.size > 0 && r.length > 0) {
+    const o = new Map(s);
+    for (const a of r) {
+      const l = o.get(a.id);
+      l && o.set(a.id, { ...l, ...a.updates });
+    }
+    const c = In(
+      i,
+      o
+    );
+    for (const a of c)
+      r.push(a);
+  }
+  return { updates: r, processedConnectorIds: i };
+}
+let En = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", kn = (t = 21) => {
+  let e = "", n = crypto.getRandomValues(new Uint8Array(t |= 0));
+  for (; t--; )
+    e += En[n[t] & 63];
+  return e;
+};
+function vt() {
+  return kn(12);
+}
+const rt = /* @__PURE__ */ new Set([
+  "rectangle",
+  "ellipse",
+  "diamond",
+  "line",
+  "arrow",
+  "freedraw",
+  "text",
+  "image"
+]), $t = /* @__PURE__ */ new Set(["left", "center", "right"]), Ut = /* @__PURE__ */ new Set(["top", "middle", "bottom"]), Ht = /* @__PURE__ */ new Set(["fit", "fill", "stretch"]), Jt = /* @__PURE__ */ new Set(["sharp", "curved", "elbow"]);
+class Tn {
+  constructor() {
+    A(this, "customs", /* @__PURE__ */ new Map());
+  }
+  // ── Registration ──────────────────────────────────────────
+  /**
+   * Register a custom element type.
+   *
+   * @throws If the type already exists and `allowOverride` is not `true`.
+   */
+  register(e) {
+    if (rt.has(e.type) && !e.allowOverride)
+      throw new Error(
+        `[f1ow] Cannot register custom element type "${e.type}" — it conflicts with a built-in type. Set allowOverride: true if you intentionally want to replace the built-in validator.`
+      );
+    if (this.customs.has(e.type) && !e.allowOverride)
+      throw new Error(
+        `[f1ow] Element type "${e.type}" is already registered. Set allowOverride: true to replace the existing registration.`
+      );
+    this.customs.set(e.type, e);
+  }
+  // ── Queries ───────────────────────────────────────────────
+  /** Returns `true` if the type is known (built-in or custom). */
+  isRegistered(e) {
+    return rt.has(e) || this.customs.has(e);
+  }
+  /** Retrieve the custom config for a type (undefined for built-in types). */
+  getCustomConfig(e) {
+    return this.customs.get(e);
+  }
+  /** All registered type names, built-in first then custom. */
+  getRegisteredTypes() {
+    return [...rt, ...this.customs.keys()];
+  }
+  // ── Validation ────────────────────────────────────────────
+  /**
+   * Validate a full element before it enters the canvas store.
+   *
+   * Checks:
+   * 1. Non-null object with required base fields (id, type, x, y, w, h, rotation, style)
+   * 2. `type` is a known/registered type
+   * 3. Type-specific field checks for all 8 built-in types
+   * 4. Custom `validate` callback (custom types only)
+   */
+  validateElement(e) {
+    if (!e || typeof e != "object" || Array.isArray(e))
+      return { valid: !1, error: "Element must be a non-null object" };
+    const n = e;
+    if (typeof n.id != "string" || n.id.trim() === "")
+      return { valid: !1, error: "Element id must be a non-empty string" };
+    const s = n.id;
+    if (typeof n.type != "string" || !this.isRegistered(n.type))
+      return {
+        valid: !1,
+        error: `Unknown element type "${n.type}". Valid types: ${this.getRegisteredTypes().join(", ")}`
+      };
+    if (typeof n.x != "number" || !isFinite(n.x))
+      return { valid: !1, error: `"${s}": x must be a finite number` };
+    if (typeof n.y != "number" || !isFinite(n.y))
+      return { valid: !1, error: `"${s}": y must be a finite number` };
+    if (typeof n.width != "number" || !isFinite(n.width) || n.width < 0)
+      return { valid: !1, error: `"${s}": width must be a non-negative finite number` };
+    if (typeof n.height != "number" || !isFinite(n.height) || n.height < 0)
+      return { valid: !1, error: `"${s}": height must be a non-negative finite number` };
+    if (typeof n.rotation != "number" || !isFinite(n.rotation))
+      return { valid: !1, error: `"${s}": rotation must be a finite number` };
+    const r = this._validateStyle(s, n.style);
+    if (!r.valid) return r;
+    if (rt.has(n.type)) {
+      const o = this._validateBuiltinFields(n);
+      if (!o.valid) return o;
+    }
+    const i = this.customs.get(n.type);
+    if (i?.validate) {
+      let o;
+      try {
+        o = i.validate(n);
+      } catch (c) {
+        return {
+          valid: !1,
+          error: `Custom element "${i.displayName ?? i.type}" validator threw for "${s}": ${c instanceof Error ? c.message : String(c)}`
+        };
+      }
+      if (o !== !0)
+        return {
+          valid: !1,
+          error: `Custom element "${i.displayName ?? i.type}" validation failed for "${s}": ${o}`
+        };
+    }
+    return { valid: !0 };
+  }
+  /**
+   * Validate a partial update before it is applied to an existing element.
+   *
+   * Prevents overwriting immutable fields (`id` and `type`), and checks
+   * numeric fields for finiteness.
+   */
+  validateUpdate(e) {
+    if ("id" in e)
+      return { valid: !1, error: "Cannot overwrite element id via updateElement" };
+    if ("type" in e)
+      return {
+        valid: !1,
+        error: "Cannot overwrite element type via updateElement — use convertElementType instead"
+      };
+    for (const n of ["x", "y", "width", "height", "rotation"])
+      if (n in e) {
+        const s = e[n];
+        if (typeof s != "number" || !isFinite(s))
+          return { valid: !1, error: `Update field "${n}" must be a finite number, got: ${s}` };
+      }
+    return { valid: !0 };
+  }
+  // ── Defaults ──────────────────────────────────────────────
+  /**
+   * Merge custom `defaults` into the element.
+   * Existing fields on the element take priority — defaults only fill gaps.
+   * Only active when the element's type has a custom config with `defaults`.
+   */
+  applyDefaults(e) {
+    const n = e.type;
+    if (!n) return e;
+    const s = this.customs.get(n);
+    return s?.defaults ? { ...s.defaults, ...e } : e;
+  }
+  // ── Private helpers ───────────────────────────────────────
+  _validateStyle(e, n) {
+    if (!n || typeof n != "object" || Array.isArray(n))
+      return { valid: !1, error: `"${e}": missing or invalid style object` };
+    const s = n;
+    return typeof s.strokeColor != "string" ? { valid: !1, error: `"${e}": style.strokeColor must be a string` } : typeof s.fillColor != "string" ? { valid: !1, error: `"${e}": style.fillColor must be a string` } : typeof s.strokeWidth != "number" || !isFinite(s.strokeWidth) || s.strokeWidth < 0 ? { valid: !1, error: `"${e}": style.strokeWidth must be a non-negative number` } : typeof s.opacity != "number" || !isFinite(s.opacity) || s.opacity < 0 || s.opacity > 1 ? { valid: !1, error: `"${e}": style.opacity must be between 0 and 1` } : typeof s.fontSize != "number" || !isFinite(s.fontSize) || s.fontSize <= 0 ? { valid: !1, error: `"${e}": style.fontSize must be a positive number` } : { valid: !0 };
+  }
+  _validateBuiltinFields(e) {
+    const n = e.type, s = e.id;
+    switch (n) {
+      case "rectangle":
+        if (typeof e.cornerRadius != "number" || !isFinite(e.cornerRadius) || e.cornerRadius < 0)
+          return {
+            valid: !1,
+            error: `rectangle "${s}": cornerRadius must be a non-negative number`
+          };
+        break;
+      case "line":
+      case "arrow": {
+        if (!Array.isArray(e.points) || e.points.length < 4 || e.points.some((r) => typeof r != "number" || !isFinite(r)))
+          return {
+            valid: !1,
+            error: `${n} "${s}": points must be an array of at least 4 finite numbers [x1,y1,x2,y2,...]`
+          };
+        if (typeof e.lineType != "string" || !Jt.has(e.lineType))
+          return {
+            valid: !1,
+            error: `${n} "${s}": lineType must be one of ${[...Jt].join(" | ")}`
+          };
+        break;
+      }
+      case "freedraw": {
+        if (!Array.isArray(e.points) || e.points.length < 2 || e.points.some((r) => typeof r != "number" || !isFinite(r)))
+          return {
+            valid: !1,
+            error: `freedraw "${s}": points must be an array of at least 2 finite numbers`
+          };
+        break;
+      }
+      case "text": {
+        if (typeof e.text != "string")
+          return { valid: !1, error: `text "${s}": text must be a string` };
+        if (!$t.has(e.textAlign))
+          return {
+            valid: !1,
+            error: `text "${s}": textAlign must be one of ${[...$t].join(" | ")}`
+          };
+        if (!Ut.has(e.verticalAlign))
+          return {
+            valid: !1,
+            error: `text "${s}": verticalAlign must be one of ${[...Ut].join(" | ")}`
+          };
+        break;
+      }
+      case "image": {
+        if (typeof e.src != "string" || e.src.trim() === "")
+          return { valid: !1, error: `image "${s}": src must be a non-empty string` };
+        if (!Ht.has(e.scaleMode))
+          return {
+            valid: !1,
+            error: `image "${s}": scaleMode must be one of ${[...Ht].join(" | ")}`
+          };
+        break;
+      }
+    }
+    return { valid: !0 };
+  }
+}
+const V = new Tn();
+function On(t) {
+  const e = { ...t };
+  return e.style && (e.style = { ...e.style }), e.boundElements && (e.boundElements = e.boundElements.map((n) => ({ ...n }))), e.startBinding && (e.startBinding = { ...e.startBinding }), e.endBinding && (e.endBinding = { ...e.endBinding }), e.groupIds && (e.groupIds = [...e.groupIds]), Array.isArray(e.points) && (e.points = [...e.points]), Array.isArray(e.pressures) && (e.pressures = [...e.pressures]), e.crop && (e.crop = { ...e.crop }), e;
+}
+function Pn(t, e, n = 20) {
+  const s = new Set(t.map((f) => f.id)), r = /* @__PURE__ */ new Set();
+  for (const f of t)
+    if (f.boundElements)
+      for (const u of f.boundElements)
+        u.type === "text" && !s.has(u.id) && r.add(u.id);
+  const i = [
+    ...t,
+    ...e.filter((f) => r.has(f.id))
+  ], o = /* @__PURE__ */ new Map();
+  for (const f of i)
+    o.set(f.id, vt());
+  const c = /* @__PURE__ */ new Map();
+  for (const f of i)
+    if (f.groupIds)
+      for (const u of f.groupIds)
+        c.has(u) || c.set(u, vt());
+  const a = i.map((f) => {
+    const u = o.get(f.id), d = On(f);
+    return d.id = u, d.x = f.x + n, d.y = f.y + n, d.containerId && o.has(d.containerId) ? d.containerId = o.get(d.containerId) : d.containerId && (d.containerId = null), d.boundElements && (d.boundElements = d.boundElements.map(
+      (m) => o.has(m.id) ? { ...m, id: o.get(m.id) } : null
+    ).filter(Boolean), d.boundElements.length === 0 && (d.boundElements = null)), d.startBinding && o.has(d.startBinding.elementId) ? d.startBinding = { ...d.startBinding, elementId: o.get(d.startBinding.elementId) } : d.startBinding && (d.startBinding = null), d.endBinding && o.has(d.endBinding.elementId) ? d.endBinding = { ...d.endBinding, elementId: o.get(d.endBinding.elementId) } : d.endBinding && (d.endBinding = null), d.groupIds && d.groupIds.length > 0 && (d.groupIds = d.groupIds.map((m) => c.get(m) ?? m)), d;
+  }), l = a.filter((f) => {
+    const u = [...o.entries()].find(([, d]) => d === f.id)?.[0];
+    return u ? s.has(u) : !1;
+  }).map((f) => f.id);
+  return { clones: a, idMap: o, selectedCloneIds: l };
+}
+function Bn(t) {
+  if ((t.type === "line" || t.type === "arrow") && "points" in t) {
+    const e = t.points;
+    let n = 0, s = 0, r = 0, i = 0;
+    for (let o = 0; o < e.length; o += 2) {
+      const c = e[o], a = e[o + 1];
+      c < n && (n = c), c > s && (s = c), a < r && (r = a), a > i && (i = a);
+    }
+    return {
+      minX: t.x + n,
+      minY: t.y + r,
+      maxX: t.x + s,
+      maxY: t.y + i
+    };
+  }
+  if (t.type === "freedraw" && "points" in t) {
+    if (t.isComplete === !1) {
+      const e = t.points;
+      let n = 1 / 0, s = -1 / 0, r = 1 / 0, i = -1 / 0;
+      for (let o = 0; o < e.length; o += 2) {
+        const c = e[o], a = e[o + 1];
+        c < n && (n = c), c > s && (s = c), a < r && (r = a), a > i && (i = a);
+      }
+      return n === 1 / 0 ? { minX: t.x, minY: t.y, maxX: t.x + 1, maxY: t.y + 1 } : { minX: n, minY: r, maxX: s, maxY: i };
+    }
+    return {
+      minX: t.x,
+      minY: t.y,
+      maxX: t.x + t.width,
+      maxY: t.y + t.height
+    };
+  }
+  return {
+    minX: t.x,
+    minY: t.y,
+    maxX: t.x + t.width,
+    maxY: t.y + t.height
+  };
+}
+const ct = [0.1, 0.25, 0.33, 0.5, 0.67, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.5, 3, 4, 5], Rn = 280;
+function jt({ viewport: t, point: e, targetScale: n }) {
+  const s = Math.min(Et, Math.max(At, n)), r = (e.x - t.x) / t.scale, i = (e.y - t.y) / t.scale;
+  return {
+    scale: s,
+    x: e.x - r * s,
+    y: e.y - i * s
+  };
+}
+function Cn(t) {
+  for (const e of ct)
+    if (e > t + 0.01) return e;
+  return Et;
+}
+function Yn(t) {
+  for (let e = ct.length - 1; e >= 0; e--)
+    if (ct[e] < t - 0.01) return ct[e];
+  return At;
+}
+function Wt(t) {
+  if (t.length === 0) return null;
+  let e = 1 / 0, n = 1 / 0, s = -1 / 0, r = -1 / 0;
+  for (const i of t) {
+    const o = Bn(i);
+    o.minX < e && (e = o.minX), o.minY < n && (n = o.minY), o.maxX > s && (s = o.maxX), o.maxY > r && (r = o.maxY);
+  }
+  return { minX: e, minY: n, maxX: s, maxY: r };
+}
+function zt(t, e, n, s = {}) {
+  const r = s.padding ?? 50, i = s.maxZoom ?? 2, o = t.maxX - t.minX, c = t.maxY - t.minY;
+  if (o === 0 && c === 0)
+    return {
+      scale: 1,
+      x: e / 2 - t.minX,
+      y: n / 2 - t.minY
+    };
+  const a = (e - r * 2) / (o || 1), l = (n - r * 2) / (c || 1), f = Math.min(Math.min(a, l), i), u = Math.min(Et, Math.max(At, f)), d = (t.minX + t.maxX) / 2, m = (t.minY + t.maxY) / 2;
+  return {
+    scale: u,
+    x: e / 2 - d * u,
+    y: n / 2 - m * u
+  };
+}
+function Ln(t) {
+  return 1 - Math.pow(1 - t, 3);
+}
+let P = null;
+function Z(t, e, n, s = Rn) {
+  P !== null && (cancelAnimationFrame(P), P = null);
+  const r = performance.now(), i = (o) => {
+    const c = o - r, a = Math.min(c / s, 1), l = Ln(a), f = {
+      x: t.x + (e.x - t.x) * l,
+      y: t.y + (e.y - t.y) * l,
+      scale: t.scale + (e.scale - t.scale) * l
+    };
+    n(f), a < 1 ? P = requestAnimationFrame(i) : (P = null, n(e));
+  };
+  return P = requestAnimationFrame(i), () => {
+    P !== null && (cancelAnimationFrame(P), P = null);
+  };
+}
+function U() {
+  P !== null && (cancelAnimationFrame(P), P = null);
+}
+const Gt = /* @__PURE__ */ new Set([
+  "x",
+  "y",
+  "width",
+  "height",
+  "rotation",
+  "ports",
+  "points",
+  "cornerRadius",
+  "radiusX",
+  "radiusY"
+]);
+function it(t, e) {
+  const n = new Set(t);
+  for (const s of e)
+    s.type === "text" && s.containerId && n.has(s.containerId) && n.add(s.id);
+  return n;
+}
+const Xn = 100;
+function M(t) {
+  if (t.type === "image" && "src" in t) {
+    const { src: e, ...n } = t, s = structuredClone(n);
+    return s.src = e, s;
+  }
+  return structuredClone(t);
+}
+function ot(t) {
+  return t.map((e) => e.id);
+}
+function Mn(t, e) {
+  return t.length === e.length && t.every((n, s) => n === e[s]);
+}
+function Vt(t, e) {
+  const n = new Map(t.map((r) => [r.id, r])), s = [];
+  for (const r of e) {
+    const i = n.get(r);
+    i && (s.push(i), n.delete(r));
+  }
+  for (const r of t)
+    n.has(r.id) && s.push(r);
+  return s;
+}
+function Zt(t, e) {
+  const n = new Set(e.map((s) => s.id));
+  return t.filter((s) => n.has(s));
+}
+function qt(t, e) {
+  const n = new Set(t);
+  return e.filter((s) => n.has(s.id) && !s.isLocked);
+}
+function It(t) {
+  if ((t.type === "line" || t.type === "arrow" || t.type === "freedraw") && t.points.length >= 2) {
+    let e = 1 / 0, n = 1 / 0, s = -1 / 0, r = -1 / 0;
+    for (let i = 0; i < t.points.length; i += 2)
+      e = Math.min(e, t.points[i]), n = Math.min(n, t.points[i + 1]), s = Math.max(s, t.points[i]), r = Math.max(r, t.points[i + 1]);
+    return {
+      minX: t.x + e,
+      minY: t.y + n,
+      maxX: t.x + s,
+      maxY: t.y + r
+    };
+  }
+  return {
+    minX: t.x,
+    minY: t.y,
+    maxX: t.x + t.width,
+    maxY: t.y + t.height
+  };
+}
+function Kt(t) {
+  if (t.length === 0) return null;
+  let e = 1 / 0, n = 1 / 0, s = -1 / 0, r = -1 / 0;
+  for (const i of t) {
+    const o = It(i);
+    e = Math.min(e, o.minX), n = Math.min(n, o.minY), s = Math.max(s, o.maxX), r = Math.max(r, o.maxY);
+  }
+  return { minX: e, minY: n, maxX: s, maxY: r };
+}
+function Dn(t) {
+  return (t % 360 + 360) % 360;
+}
+function Qt(t, e, n, s) {
+  if (t)
+    return t.map((r, i) => i % 2 === s ? e + n - r : r);
+}
+function yt(t, e) {
+  const n = e(), s = An(t, n.elements);
+  s.updates.length > 0 && n.batchUpdateElements(s.updates);
+}
+function Nn() {
+  return _e((t, e) => ({
+    // ─── Initial State ────────────────────────────────────────
+    elements: [],
+    selectedIds: [],
+    activeTool: "select",
+    currentStyle: { ...De },
+    currentLineType: "sharp",
+    currentStartArrowhead: null,
+    currentEndArrowhead: "arrow",
+    viewport: { x: 0, y: 0, scale: 1 },
+    isDrawing: !1,
+    drawStart: null,
+    history: [],
+    historyIndex: -1,
+    _historyBaseline: /* @__PURE__ */ new Map(),
+    _historyOrderBaseline: [],
+    _historyPaused: !1,
+    showGrid: !1,
+    // ─── Element Actions ──────────────────────────────────────
+    addElement: (n) => {
+      if (!V.validateElement(n).valid)
+        return;
+      const r = V.applyDefaults(n);
+      t((i) => ({
+        elements: [...i.elements, r]
+      })), e().pushHistory();
+    },
+    updateElement: (n, s) => {
+      if (!V.validateUpdate(s).valid)
+        return;
+      const i = Object.keys(s).some((o) => Gt.has(o));
+      t((o) => {
+        const c = o.elements, a = c.findIndex((m) => m.id === n);
+        if (a === -1) return o;
+        const l = c[a], f = i ? { version: (l.version ?? 0) + 1 } : {}, u = { ...l, ...s, ...f };
+        if (u === l) return o;
+        const d = c.slice();
+        return d[a] = u, { elements: d };
+      });
+    },
+    batchUpdateElements: (n) => {
+      if (n.length === 0) return;
+      if (n.length === 1) {
+        e().updateElement(n[0].id, n[0].updates);
+        return;
+      }
+      const s = n.filter(({ id: r, updates: i }) => !!V.validateUpdate(i).valid);
+      s.length !== 0 && t((r) => {
+        const i = r.elements, o = /* @__PURE__ */ new Map();
+        for (let a = 0; a < i.length; a++)
+          o.set(i[a].id, a);
+        let c = null;
+        for (const { id: a, updates: l } of s) {
+          const f = o.get(a);
+          if (f === void 0) continue;
+          const u = c ? c[f] : i[f], m = Object.keys(l).some((g) => Gt.has(g)) ? { version: (u.version ?? 0) + 1 } : {}, h = { ...u, ...l, ...m };
+          h !== u && (c || (c = i.slice()), c[f] = h);
+        }
+        return c ? { elements: c } : r;
+      });
+    },
+    deleteElements: (n) => {
+      const s = new Set(n), { elements: r } = e();
+      for (const i of r)
+        if (s.has(i.id) && i.boundElements)
+          for (const o of i.boundElements)
+            o.type === "text" && s.add(o.id);
+      for (const i of r)
+        i.type === "text" && "containerId" in i && i.containerId && s.has(i.containerId) && s.add(i.id);
+      t((i) => {
+        const o = i.elements.filter((a) => !s.has(a.id));
+        return {
+          elements: bn(s, o),
+          selectedIds: i.selectedIds.filter((a) => !s.has(a))
+        };
+      }), e().pushHistory();
+    },
+    setElements: (n) => {
+      if (n === e().elements) return;
+      const s = n.filter((i) => {
+        const o = V.validateElement(i);
+        return o.valid, o.valid;
+      }), r = /* @__PURE__ */ new Map();
+      for (const i of s)
+        r.set(i.id, i);
+      t({ elements: s, _historyBaseline: r, _historyOrderBaseline: ot(s) });
+    },
+    duplicateElements: (n) => {
+      const { elements: s } = e(), r = s.filter((c) => n.includes(c.id)), { clones: i, selectedCloneIds: o } = Pn(r, s);
+      t((c) => ({
+        elements: [...c.elements, ...i],
+        selectedIds: o.length > 0 ? o : i.map((a) => a.id)
+      })), e().pushHistory();
+    },
+    convertElementType: (n, s) => {
+      const r = /* @__PURE__ */ new Set(["rectangle", "ellipse", "diamond"]);
+      r.has(s) && (t((i) => ({
+        elements: i.elements.map((o) => {
+          if (!n.includes(o.id) || !r.has(o.type) || o.type === s) return o;
+          const { cornerRadius: c, ...a } = o, l = { ...a, type: s };
+          return s === "rectangle" ? { ...l, cornerRadius: 0 } : l;
+        })
+      })), e().pushHistory());
+    },
+    bringToFront: (n) => {
+      t((s) => {
+        const r = it(n, s.elements), i = s.elements.filter((c) => !r.has(c.id)), o = s.elements.filter((c) => r.has(c.id));
+        return { elements: [...i, ...o] };
+      }), e().pushHistory();
+    },
+    sendToBack: (n) => {
+      t((s) => {
+        const r = it(n, s.elements), i = s.elements.filter((c) => !r.has(c.id));
+        return { elements: [...s.elements.filter((c) => r.has(c.id)), ...i] };
+      }), e().pushHistory();
+    },
+    bringForward: (n) => {
+      t((s) => {
+        const r = [...s.elements], i = it(n, s.elements);
+        for (let o = r.length - 2; o >= 0; o--)
+          i.has(r[o].id) && !i.has(r[o + 1].id) && ([r[o], r[o + 1]] = [r[o + 1], r[o]]);
+        return { elements: r };
+      }), e().pushHistory();
+    },
+    sendBackward: (n) => {
+      t((s) => {
+        const r = [...s.elements], i = it(n, s.elements);
+        for (let o = 1; o < r.length; o++)
+          i.has(r[o].id) && !i.has(r[o - 1].id) && ([r[o], r[o - 1]] = [r[o - 1], r[o]]);
+        return { elements: r };
+      }), e().pushHistory();
+    },
+    // ─── Transforms ──────────────────────────────────────────
+    alignElements: (n, s) => {
+      const r = [];
+      t((i) => {
+        const o = qt(n, i.elements);
+        if (o.length < 2) return i;
+        const c = Kt(o);
+        if (!c) return i;
+        const a = (c.minX + c.maxX) / 2, l = (c.minY + c.maxY) / 2, f = new Set(o.map((h) => h.id)), u = new Map(o.map((h) => [h.id, It(h)]));
+        let d = !1;
+        const m = i.elements.map((h) => {
+          if (!f.has(h.id)) return h;
+          const g = u.get(h.id);
+          if (!g) return h;
+          let p = h.x, x = h.y;
+          return s === "left" && (p += c.minX - g.minX), s === "centerH" && (p += a - (g.minX + g.maxX) / 2), s === "right" && (p += c.maxX - g.maxX), s === "top" && (x += c.minY - g.minY), s === "centerV" && (x += l - (g.minY + g.maxY) / 2), s === "bottom" && (x += c.maxY - g.maxY), p === h.x && x === h.y ? h : (d = !0, r.push(h.id), { ...h, x: p, y: x, version: (h.version ?? 0) + 1 });
+        });
+        return d ? { elements: m } : i;
+      }), r.length > 0 && (yt(r, e), e().pushHistory());
+    },
+    rotateElements: (n, s) => {
+      const r = [];
+      t((i) => {
+        const o = new Set(n);
+        let c = !1;
+        const a = i.elements.map((l) => {
+          if (!o.has(l.id) || l.isLocked) return l;
+          const f = Dn((l.rotation ?? 0) + s);
+          return f === l.rotation ? l : (c = !0, r.push(l.id), { ...l, rotation: f, version: (l.version ?? 0) + 1 });
+        });
+        return c ? { elements: a } : i;
+      }), r.length > 0 && (yt(r, e), e().pushHistory());
+    },
+    flipElements: (n, s) => {
+      const r = [];
+      t((i) => {
+        const o = qt(n, i.elements);
+        if (o.length === 0) return i;
+        const c = Kt(o);
+        if (!c) return i;
+        const a = new Set(o.map((d) => d.id)), l = new Map(o.map((d) => [d.id, It(d)]));
+        let f = !1;
+        const u = i.elements.map((d) => {
+          if (!a.has(d.id)) return d;
+          const m = l.get(d.id);
+          if (!m) return d;
+          const h = {};
+          return s === "horizontal" ? (h.x = d.x + c.minX + c.maxX - m.minX - m.maxX, (d.type === "line" || d.type === "arrow" || d.type === "freedraw") && (h.points = Qt(d.points, m.minX - d.x, m.maxX - d.x, 0))) : (h.y = d.y + c.minY + c.maxY - m.minY - m.maxY, (d.type === "line" || d.type === "arrow" || d.type === "freedraw") && (h.points = Qt(d.points, m.minY - d.y, m.maxY - d.y, 1))), f = !0, r.push(d.id), { ...d, ...h, version: (d.version ?? 0) + 1 };
+        });
+        return f ? { elements: u } : i;
+      }), r.length > 0 && (yt(r, e), e().pushHistory());
+    },
+    // ─── Lock ─────────────────────────────────────────────────
+    toggleLockElements: (n) => {
+      t((s) => ({
+        elements: s.elements.map(
+          (r) => n.includes(r.id) ? { ...r, isLocked: !r.isLocked } : r
+        )
+      })), e().pushHistory();
+    },
+    // ─── Grouping ─────────────────────────────────────────────
+    groupElements: (n) => {
+      if (n.length < 2) return;
+      const s = vt(), r = new Set(n), { elements: i } = e();
+      for (const o of i)
+        if (r.has(o.id) && o.boundElements)
+          for (const c of o.boundElements)
+            c.type === "text" && r.add(c.id);
+      t((o) => ({
+        elements: o.elements.map(
+          (c) => r.has(c.id) ? { ...c, groupIds: [...c.groupIds ?? [], s] } : c
+        )
+      })), e().pushHistory();
+    },
+    ungroupElements: (n) => {
+      const { elements: s } = e(), r = s.filter((o) => n.includes(o.id)), i = /* @__PURE__ */ new Set();
+      for (const o of r)
+        o.groupIds?.length && i.add(o.groupIds[o.groupIds.length - 1]);
+      i.size !== 0 && (t((o) => ({
+        elements: o.elements.map((c) => {
+          if (!c.groupIds?.length) return c;
+          const a = c.groupIds.filter((l) => !i.has(l));
+          return {
+            ...c,
+            groupIds: a.length > 0 ? a : void 0
+          };
+        })
+      })), e().pushHistory());
+    },
+    // ─── Selection ────────────────────────────────────────────
+    setSelectedIds: (n) => t({ selectedIds: n }),
+    clearSelection: () => t({ selectedIds: [] }),
+    // ─── Tool ─────────────────────────────────────────────────
+    setActiveTool: (n) => t((s) => ({
+      activeTool: n,
+      // Keep selection when switching back to 'select' (e.g. after creating an element)
+      selectedIds: n === "select" ? s.selectedIds : []
+    })),
+    setCurrentStyle: (n) => t((s) => ({
+      currentStyle: { ...s.currentStyle, ...n }
+    })),
+    setCurrentLineType: (n) => t({ currentLineType: n }),
+    setCurrentStartArrowhead: (n) => t({ currentStartArrowhead: n }),
+    setCurrentEndArrowhead: (n) => t({ currentEndArrowhead: n }),
+    // ─── Viewport ─────────────────────────────────────────────
+    setViewport: (n) => {
+      U(), t((s) => ({
+        viewport: { ...s.viewport, ...n }
+      }));
+    },
+    zoomIn: (n, s) => {
+      const { viewport: r } = e(), i = Cn(r.scale), c = jt({ viewport: r, point: n ?? { x: 400, y: 300 }, targetScale: i });
+      s?.animate ? Z(r, c, (a) => t((l) => ({ viewport: { ...l.viewport, ...a } }))) : (U(), t({ viewport: c }));
+    },
+    zoomOut: (n, s) => {
+      const { viewport: r } = e(), i = Yn(r.scale), c = jt({ viewport: r, point: n ?? { x: 400, y: 300 }, targetScale: i });
+      s?.animate ? Z(r, c, (a) => t((l) => ({ viewport: { ...l.viewport, ...a } }))) : (U(), t({ viewport: c }));
+    },
+    resetZoom: (n) => {
+      const { viewport: s } = e(), r = { x: 0, y: 0, scale: 1 };
+      n?.animate ? Z(s, r, (i) => t((o) => ({ viewport: { ...o.viewport, ...i } }))) : (U(), t({ viewport: r }));
+    },
+    zoomToFit: (n, s, r, i) => {
+      const { elements: o, viewport: c } = e(), a = r ? o.filter((u) => r.includes(u.id)) : o, l = Wt(a);
+      if (!l) return;
+      const f = zt(l, n, s, {
+        padding: i?.padding,
+        maxZoom: i?.maxZoom
+      });
+      i?.animate ? Z(c, f, (u) => t((d) => ({ viewport: { ...d.viewport, ...u } }))) : (U(), t({ viewport: f }));
+    },
+    zoomToSelection: (n, s, r) => {
+      const { elements: i, selectedIds: o, viewport: c } = e();
+      if (o.length === 0) return;
+      const a = i.filter((u) => o.includes(u.id)), l = Wt(a);
+      if (!l) return;
+      const f = zt(l, n, s, {
+        padding: r?.padding ?? 80,
+        maxZoom: r?.maxZoom ?? 2
+      });
+      r?.animate ? Z(c, f, (u) => t((d) => ({ viewport: { ...d.viewport, ...u } }))) : (U(), t({ viewport: f }));
+    },
+    // ─── Drawing ──────────────────────────────────────────────
+    setIsDrawing: (n) => t({ isDrawing: n }),
+    setDrawStart: (n) => t({ drawStart: n }),
+    // ─── History (Diff-based) ───────────────────────────────────
+    pushHistory: (n) => {
+      const { elements: s, _historyBaseline: r, _historyOrderBaseline: i, _historyPaused: o } = e();
+      if (o) return;
+      const c = [], a = /* @__PURE__ */ new Map();
+      for (const u of s)
+        a.set(u.id, u);
+      const l = ot(s), f = !Mn(i, l);
+      for (const u of s) {
+        const d = r.get(u.id);
+        d ? d !== u && c.push({
+          type: "modify",
+          elementId: u.id,
+          before: M(d),
+          after: M(u)
+        }) : c.push({ type: "add", elementId: u.id, after: M(u) });
+      }
+      for (const [u, d] of r)
+        a.has(u) || c.push({ type: "delete", elementId: u, before: M(d) });
+      c.length === 0 && !f || t((u) => {
+        const d = u.history.slice(0, u.historyIndex + 1);
+        return d.push({
+          diffs: c,
+          beforeOrder: f ? i : void 0,
+          afterOrder: f ? l : void 0,
+          mark: n,
+          timestamp: Date.now()
+        }), d.length > Xn && d.shift(), {
+          history: d,
+          historyIndex: d.length - 1,
+          // Update baseline to current state
+          _historyBaseline: new Map(a),
+          _historyOrderBaseline: l
+        };
+      });
+    },
+    undo: () => {
+      const { historyIndex: n, history: s } = e();
+      if (n < 0) return;
+      const r = s[n];
+      t((i) => {
+        let o = [...i.elements];
+        for (let a = r.diffs.length - 1; a >= 0; a--) {
+          const l = r.diffs[a];
+          switch (l.type) {
+            case "add":
+              o = o.filter((f) => f.id !== l.elementId);
+              break;
+            case "modify":
+              o = o.map(
+                (f) => f.id === l.elementId ? M(l.before) : f
+              );
+              break;
+            case "delete":
+              o.push(M(l.before));
+              break;
+          }
+        }
+        r.beforeOrder && (o = Vt(o, r.beforeOrder));
+        const c = /* @__PURE__ */ new Map();
+        for (const a of o)
+          c.set(a.id, a);
+        return {
+          historyIndex: n - 1,
+          elements: o,
+          selectedIds: Zt(i.selectedIds, o),
+          _historyBaseline: c,
+          _historyOrderBaseline: ot(o)
+        };
+      });
+    },
+    redo: () => {
+      const { historyIndex: n, history: s } = e();
+      if (n >= s.length - 1) return;
+      const r = n + 1, i = s[r];
+      t((o) => {
+        let c = [...o.elements];
+        for (const l of i.diffs)
+          switch (l.type) {
+            case "add":
+              c.push(M(l.after));
+              break;
+            case "modify":
+              c = c.map(
+                (f) => f.id === l.elementId ? M(l.after) : f
+              );
+              break;
+            case "delete":
+              c = c.filter((f) => f.id !== l.elementId);
+              break;
+          }
+        i.afterOrder && (c = Vt(c, i.afterOrder));
+        const a = /* @__PURE__ */ new Map();
+        for (const l of c)
+          a.set(l.id, l);
+        return {
+          historyIndex: r,
+          elements: c,
+          selectedIds: Zt(o.selectedIds, c),
+          _historyBaseline: a,
+          _historyOrderBaseline: ot(c)
+        };
+      });
+    },
+    squashHistory: (n = 2) => {
+      t((s) => {
+        if (s.history.length < n) return s;
+        const r = Math.max(0, s.history.length - n), i = s.history.slice(r), o = /* @__PURE__ */ new Map();
+        for (const l of i)
+          for (const f of l.diffs) {
+            const u = o.get(f.elementId);
+            u ? f.type === "delete" ? u.type === "add" ? o.delete(f.elementId) : o.set(f.elementId, {
+              type: "delete",
+              elementId: f.elementId,
+              before: u.before
+            }) : f.type === "modify" && o.set(f.elementId, {
+              type: u.type === "add" ? "add" : "modify",
+              elementId: f.elementId,
+              before: u.before,
+              after: f.after
+            }) : o.set(f.elementId, { ...f });
+          }
+        const c = {
+          diffs: Array.from(o.values()),
+          beforeOrder: i.find((l) => l.beforeOrder)?.beforeOrder,
+          afterOrder: [...i].reverse().find((l) => l.afterOrder)?.afterOrder,
+          mark: i[i.length - 1].mark,
+          timestamp: Date.now()
+        }, a = [...s.history.slice(0, r), c];
+        return {
+          history: a,
+          historyIndex: a.length - 1
+        };
+      });
+    },
+    pauseHistory: () => t({ _historyPaused: !0 }),
+    resumeHistory: () => t({ _historyPaused: !1 }),
+    canUndo: () => e().historyIndex >= 0,
+    canRedo: () => {
+      const { historyIndex: n, history: s } = e();
+      return n < s.length - 1;
+    },
+    // ─── Grid ─────────────────────────────────────────────────
+    toggleGrid: () => t((n) => ({ showGrid: !n.showGrid }))
+  }));
+}
+const H = Nn(), pe = [
+  "id",
+  "type",
+  "x",
+  "y",
+  "width",
+  "height",
+  "rotation",
+  "isLocked",
+  "isVisible",
+  "sortOrder",
+  "version"
+], kt = [
+  "strokeColor",
+  "fillColor",
+  "strokeWidth",
+  "opacity",
+  "strokeStyle",
+  "roughness",
+  "fontSize",
+  "fontFamily"
+];
+function ut(t, e) {
+  const n = t;
+  for (const s of pe) {
+    const r = n[s];
+    r !== void 0 && e.set(s, r);
+  }
+  if (t.style)
+    for (const s of kt)
+      e.set(`style.${s}`, t.style[s]);
+  switch (t.boundElements ? e.set("boundElements", JSON.stringify(t.boundElements)) : e.set("boundElements", null), t.ports && e.set("ports", JSON.stringify(t.ports)), "lineStyle" in t && t.lineStyle && e.set("lineStyle", JSON.stringify(t.lineStyle)), t.ports && e.set("ports", JSON.stringify(t.ports)), "lineStyle" in t && t.lineStyle && e.set("lineStyle", JSON.stringify(t.lineStyle)), t.groupIds && e.set("groupIds", JSON.stringify(t.groupIds)), t.type) {
+    case "rectangle":
+      e.set("cornerRadius", t.cornerRadius);
+      break;
+    case "line":
+    case "arrow":
+      e.set("points", JSON.stringify(t.points)), e.set("lineType", t.lineType), t.curvature !== void 0 && e.set("curvature", t.curvature), e.set("startBinding", t.startBinding ? JSON.stringify(t.startBinding) : null), e.set("endBinding", t.endBinding ? JSON.stringify(t.endBinding) : null), t.type === "arrow" && (e.set("startArrowhead", t.startArrowhead), e.set("endArrowhead", t.endArrowhead));
+      break;
+    case "freedraw":
+      e.set("points", JSON.stringify(t.points));
+      break;
+    case "text":
+      e.set("text", t.text), e.set("containerId", t.containerId), e.set("textAlign", t.textAlign), e.set("verticalAlign", t.verticalAlign);
+      break;
+    case "image":
+      e.set("src", t.src), e.set("naturalWidth", t.naturalWidth), e.set("naturalHeight", t.naturalHeight), e.set("scaleMode", t.scaleMode), e.set("crop", t.crop ? JSON.stringify(t.crop) : null), e.set("cornerRadius", t.cornerRadius), e.set("alt", t.alt);
+      break;
+  }
+}
+function j(t) {
+  const e = t.get("type"), n = t.get("id");
+  if (!e || !n) return null;
+  const s = {};
+  for (const i of kt) {
+    const o = t.get(`style.${i}`);
+    o !== void 0 && (s[i] = o);
+  }
+  const r = {
+    id: n,
+    type: e,
+    x: t.get("x") ?? 0,
+    y: t.get("y") ?? 0,
+    width: t.get("width") ?? 100,
+    height: t.get("height") ?? 100,
+    rotation: t.get("rotation") ?? 0,
+    isLocked: t.get("isLocked") ?? !1,
+    isVisible: t.get("isVisible") ?? !0,
+    version: t.get("version") ?? 0,
+    style: s,
+    boundElements: C(t.get("boundElements")) ?? null,
+    groupIds: C(t.get("groupIds")) ?? void 0,
+    sortOrder: t.get("sortOrder") ?? void 0,
+    ports: C(t.get("ports")) ?? void 0
+  };
+  switch (e) {
+    case "rectangle":
+      r.cornerRadius = t.get("cornerRadius") ?? 0;
+      break;
+    case "line":
+    case "arrow":
+      r.points = C(t.get("points")) ?? [0, 0, 100, 0], r.lineType = t.get("lineType") ?? "sharp", r.curvature = t.get("curvature") ?? void 0, r.startBinding = C(t.get("startBinding")), r.endBinding = C(t.get("endBinding")), e === "arrow" && (r.startArrowhead = t.get("startArrowhead") ?? null, r.endArrowhead = t.get("endArrowhead") ?? "arrow");
+      {
+        const i = C(t.get("lineStyle"));
+        i && (r.lineStyle = i);
+      }
+      break;
+    case "freedraw":
+      r.points = C(t.get("points")) ?? [];
+      break;
+    case "text":
+      r.text = t.get("text") ?? "", r.containerId = t.get("containerId") ?? null, r.textAlign = t.get("textAlign") ?? "center", r.verticalAlign = t.get("verticalAlign") ?? "middle";
+      break;
+    case "image":
+      r.src = t.get("src") ?? "", r.naturalWidth = t.get("naturalWidth") ?? 0, r.naturalHeight = t.get("naturalHeight") ?? 0, r.scaleMode = t.get("scaleMode") ?? "fit", r.crop = C(t.get("crop")) ?? null, r.cornerRadius = t.get("cornerRadius") ?? 0, r.alt = t.get("alt") ?? "";
+      break;
+  }
+  return r;
+}
+function C(t) {
+  if (t == null) return null;
+  try {
+    return JSON.parse(t);
+  } catch {
+    return null;
+  }
+}
+let N = !1, F = !1, at = null, lt = null, W = null, X = [];
+function Fn(t = 50) {
+  const e = oe(), n = ce();
+  if (!e || !n)
+    return;
+  if (xe(), n.size > 0) {
+    N = !0;
+    const c = Hn(n);
+    H.getState().setElements(c), X = c, N = !1;
+  } else {
+    const c = H.getState().elements;
+    c.length > 0 && (F = !0, e.transact(() => {
+      for (const a of c) {
+        const l = new R.Map();
+        ut(a, l), n.set(a.id, l);
+      }
+    }, "local-init"), F = !1), X = c;
+  }
+  const s = (c, a) => {
+    if (a.origin === "local-sync" || a.origin === "local-init" || F) return;
+    N = !0;
+    const l = H.getState();
+    let f = [...X], u = !1;
+    for (const [d, m] of c.keys)
+      if (m.action === "add" || m.action === "update") {
+        const h = n.get(d);
+        if (h) {
+          const g = j(h);
+          if (g) {
+            const p = f.findIndex((x) => x.id === d);
+            p >= 0 ? f[p] = g : f.push(g), u = !0;
+          }
+        }
+      } else m.action === "delete" && (f = f.filter((h) => h.id !== d), u = !0);
+    u && (f.sort((d, m) => d.sortOrder && m.sortOrder ? d.sortOrder < m.sortOrder ? -1 : d.sortOrder > m.sortOrder ? 1 : 0 : 0), l.setElements(f), X = f), N = !1;
+  };
+  let r = null;
+  const i = /* @__PURE__ */ new Set(), o = (c) => {
+    if (!F) {
+      for (const a of c) {
+        let l = a.target;
+        for (; l && !(l instanceof R.Map && l.parent === n); )
+          l = l.parent;
+        if (l instanceof R.Map) {
+          const f = l.get("id");
+          f && i.add(f);
+        }
+      }
+      r && clearTimeout(r), r = setTimeout(() => {
+        if (i.size === 0 || F) return;
+        N = !0;
+        let a = [...X], l = !1;
+        for (const f of i) {
+          const u = n.get(f);
+          if (!u) continue;
+          const d = j(u);
+          if (!d) continue;
+          const m = a.findIndex((h) => h.id === f);
+          m >= 0 && (a[m] = d, l = !0);
+        }
+        i.clear(), l && (H.getState().setElements(a), X = a), N = !1;
+      }, 16);
+    }
+  };
+  n.observe(s), n.observeDeep(o), lt = () => {
+    n.unobserve(s), n.unobserveDeep(o), r && clearTimeout(r), i.clear();
+  }, at = H.subscribe(
+    (c) => {
+      N || c.elements !== X && (W && clearTimeout(W), W = setTimeout(() => {
+        $n(c.elements, n, e);
+      }, t));
+    }
+  );
+}
+function xe() {
+  at && (at(), at = null), lt && (lt(), lt = null), W && (clearTimeout(W), W = null), X = [];
+}
+function $n(t, e, n) {
+  F = !0, X = t;
+  const s = /* @__PURE__ */ new Map();
+  for (const r of t)
+    s.set(r.id, r);
+  n.transact(() => {
+    for (const [r] of e.entries())
+      s.has(r) || e.delete(r);
+    for (const r of t) {
+      let i = e.get(r.id);
+      i ? Un(r, i) : (i = new R.Map(), ut(r, i), e.set(r.id, i));
+    }
+  }, "local-sync"), F = !1;
+}
+function Un(t, e) {
+  const n = t;
+  for (const r of pe) {
+    const i = n[r];
+    i !== e.get(r) && e.set(r, i);
+  }
+  if (t.style)
+    for (const r of kt) {
+      const i = t.style[r];
+      i !== e.get(`style.${r}`) && e.set(`style.${r}`, i);
+    }
+  const s = t.boundElements ? JSON.stringify(t.boundElements) : null;
+  switch (s !== e.get("boundElements") && e.set("boundElements", s), t.type) {
+    case "rectangle":
+      t.cornerRadius !== e.get("cornerRadius") && e.set("cornerRadius", t.cornerRadius);
+      break;
+    case "line":
+    case "arrow": {
+      const i = JSON.stringify(t.points);
+      i !== e.get("points") && e.set("points", i), t.lineType !== e.get("lineType") && e.set("lineType", t.lineType), t.curvature !== e.get("curvature") && e.set("curvature", t.curvature);
+      const o = t.startBinding ? JSON.stringify(t.startBinding) : null;
+      o !== e.get("startBinding") && e.set("startBinding", o);
+      const c = t.endBinding ? JSON.stringify(t.endBinding) : null;
+      c !== e.get("endBinding") && e.set("endBinding", c), t.type === "arrow" && (t.startArrowhead !== e.get("startArrowhead") && e.set("startArrowhead", t.startArrowhead), t.endArrowhead !== e.get("endArrowhead") && e.set("endArrowhead", t.endArrowhead));
+      break;
+    }
+    case "freedraw": {
+      const i = JSON.stringify(t.points);
+      i !== e.get("points") && e.set("points", i);
+      break;
+    }
+    case "text":
+      t.text !== e.get("text") && e.set("text", t.text), t.containerId !== e.get("containerId") && e.set("containerId", t.containerId), t.textAlign !== e.get("textAlign") && e.set("textAlign", t.textAlign), t.verticalAlign !== e.get("verticalAlign") && e.set("verticalAlign", t.verticalAlign);
+      break;
+    case "image":
+      t.src !== e.get("src") && e.set("src", t.src), t.naturalWidth !== e.get("naturalWidth") && e.set("naturalWidth", t.naturalWidth), t.naturalHeight !== e.get("naturalHeight") && e.set("naturalHeight", t.naturalHeight), t.scaleMode !== e.get("scaleMode") && e.set("scaleMode", t.scaleMode);
+      const r = t.crop ? JSON.stringify(t.crop) : null;
+      r !== e.get("crop") && e.set("crop", r), t.cornerRadius !== e.get("cornerRadius") && e.set("cornerRadius", t.cornerRadius), t.alt !== e.get("alt") && e.set("alt", t.alt);
+      break;
+  }
+}
+function Hn(t) {
+  const e = [];
+  for (const [, n] of t.entries()) {
+    const s = j(n);
+    s && e.push(s);
+  }
+  return e.sort((n, s) => n.sortOrder && s.sortOrder ? n.sortOrder < s.sortOrder ? -1 : n.sortOrder > s.sortOrder ? 1 : 0 : 0), e;
+}
+const Jn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  startSync: Fn,
+  stopSync: xe
+}, Symbol.toStringTag, { value: "Module" }));
+class rs {
+  constructor() {
+    // Provider state
+    A(this, "_doc", null);
+    A(this, "_provider", null);
+    A(this, "_config", null);
+    // Sync state
+    A(this, "_isApplyingRemote", !1);
+    A(this, "_isApplyingLocal", !1);
+    A(this, "_lastElements", []);
+    A(this, "_syncTimer", null);
+    A(this, "_deepTimer", null);
+    A(this, "_dirtyIds", /* @__PURE__ */ new Set());
+    A(this, "_storeUnsub", null);
+    A(this, "_yObserverCleanup", null);
+    // Status listeners
+    A(this, "_statusListeners", /* @__PURE__ */ new Set());
+  }
+  // ─── Provider Lifecycle ───────────────────────────────────
+  get doc() {
+    return this._doc;
+  }
+  get provider() {
+    return this._provider;
+  }
+  get config() {
+    return this._config;
+  }
+  get isActive() {
+    return this._provider !== null && this._provider.wsconnected;
+  }
+  /**
+   * Connect to a collaboration room.
+   * If already connected, disconnects first.
+   */
+  connect(e) {
+    return this.dispose(), this._config = e, this._doc = new R.Doc(), this._provider = new re(
+      e.serverUrl,
+      e.roomName,
+      this._doc,
+      {
+        connect: !0,
+        params: e.authToken ? { token: e.authToken } : void 0
+      }
+    ), this._provider.awareness.setLocalState({
+      user: e.user,
+      cursor: null,
+      selectedIds: []
+    }), this._provider.on("status", (n) => {
+      const s = n.status;
+      for (const r of this._statusListeners)
+        r(s);
+    }), { doc: this._doc, provider: this._provider };
+  }
+  /**
+   * Get the shared Y.Map for elements.
+   */
+  getYElements() {
+    return this._doc?.getMap("elements");
+  }
+  // ─── Awareness ────────────────────────────────────────────
+  updateAwareness(e) {
+    if (!this._provider) return;
+    const n = this._provider.awareness.getLocalState();
+    this._provider.awareness.setLocalState({ ...n, ...e });
+  }
+  getRemoteAwareness() {
+    if (!this._provider) return /* @__PURE__ */ new Map();
+    const e = this._provider.awareness.getStates(), n = this._provider.awareness.clientID, s = /* @__PURE__ */ new Map();
+    for (const [r, i] of e)
+      r !== n && i && i.user && s.set(r, i);
+    return s;
+  }
+  // ─── Status Listeners ─────────────────────────────────────
+  onStatusChange(e) {
+    return this._statusListeners.add(e), () => {
+      this._statusListeners.delete(e);
+    };
+  }
+  // ─── Sync Bridge ─────────────────────────────────────────
+  /**
+   * Start bidirectional sync between Yjs and the provided store.
+   */
+  startSync(e, n = 50) {
+    const s = this._doc, r = this.getYElements();
+    if (!s || !r)
+      return;
+    if (this.stopSync(), r.size > 0) {
+      this._isApplyingRemote = !0;
+      const c = this._yMapCollectionToElements(r);
+      e.setElements(c), this._lastElements = c, this._isApplyingRemote = !1;
+    } else {
+      const c = e.getState().elements;
+      c.length > 0 && (this._isApplyingLocal = !0, s.transact(() => {
+        for (const a of c) {
+          const l = new R.Map();
+          ut(a, l), r.set(a.id, l);
+        }
+      }, "local-init"), this._isApplyingLocal = !1), this._lastElements = c;
+    }
+    const i = (c, a) => {
+      if (a.origin === "local-sync" || a.origin === "local-init" || this._isApplyingLocal) return;
+      this._isApplyingRemote = !0;
+      let l = [...this._lastElements], f = !1;
+      for (const [u, d] of c.keys)
+        if (d.action === "add" || d.action === "update") {
+          const m = r.get(u);
+          if (m) {
+            const h = j(m);
+            if (h) {
+              const g = l.findIndex((p) => p.id === u);
+              g >= 0 ? l[g] = h : l.push(h), f = !0;
+            }
+          }
+        } else d.action === "delete" && (l = l.filter((m) => m.id !== u), f = !0);
+      f && (l.sort((u, d) => u.sortOrder && d.sortOrder ? u.sortOrder < d.sortOrder ? -1 : u.sortOrder > d.sortOrder ? 1 : 0 : 0), e.setElements(l), this._lastElements = l), this._isApplyingRemote = !1;
+    }, o = (c) => {
+      if (!this._isApplyingLocal) {
+        for (const a of c) {
+          let l = a.target;
+          for (; l && !(l instanceof R.Map && l.parent === r); )
+            l = l.parent;
+          if (l instanceof R.Map) {
+            const f = l.get("id");
+            f && this._dirtyIds.add(f);
+          }
+        }
+        this._deepTimer && clearTimeout(this._deepTimer), this._deepTimer = setTimeout(() => {
+          if (this._dirtyIds.size === 0 || this._isApplyingLocal) return;
+          this._isApplyingRemote = !0;
+          let a = [...this._lastElements], l = !1;
+          for (const f of this._dirtyIds) {
+            const u = r.get(f);
+            if (!u) continue;
+            const d = j(u);
+            if (!d) continue;
+            const m = a.findIndex((h) => h.id === f);
+            m >= 0 && (a[m] = d, l = !0);
+          }
+          this._dirtyIds.clear(), l && (e.setElements(a), this._lastElements = a), this._isApplyingRemote = !1;
+        }, 16);
+      }
+    };
+    r.observe(i), r.observeDeep(o), this._yObserverCleanup = () => {
+      r.unobserve(i), r.unobserveDeep(o), this._deepTimer && clearTimeout(this._deepTimer), this._dirtyIds.clear();
+    }, this._storeUnsub = e.subscribe((c) => {
+      this._isApplyingRemote || c.elements !== this._lastElements && (this._syncTimer && clearTimeout(this._syncTimer), this._syncTimer = setTimeout(() => {
+        this._syncLocalToYjs(c.elements, r, s);
+      }, n));
+    });
+  }
+  stopSync() {
+    this._storeUnsub?.(), this._storeUnsub = null, this._yObserverCleanup?.(), this._yObserverCleanup = null, this._syncTimer && (clearTimeout(this._syncTimer), this._syncTimer = null), this._lastElements = [];
+  }
+  // ─── Dispose ──────────────────────────────────────────────
+  dispose() {
+    this.stopSync(), this._provider && (this._provider.awareness.setLocalState(null), this._provider.disconnect(), this._provider.destroy(), this._provider = null), this._doc && (this._doc.destroy(), this._doc = null), this._config = null, this._statusListeners.clear();
+  }
+  // ─── Private ──────────────────────────────────────────────
+  _syncLocalToYjs(e, n, s) {
+    this._isApplyingLocal = !0, this._lastElements = e;
+    const r = /* @__PURE__ */ new Map();
+    for (const i of e) r.set(i.id, i);
+    s.transact(() => {
+      for (const [i] of n.entries())
+        r.has(i) || n.delete(i);
+      for (const i of e) {
+        let o = n.get(i.id);
+        o ? this._updateYMapFromElement(i, o) : (o = new R.Map(), ut(i, o), n.set(i.id, o));
+      }
+    }, "local-sync"), this._isApplyingLocal = !1;
+  }
+  _updateYMapFromElement(e, n) {
+    const s = [
+      "id",
+      "type",
+      "x",
+      "y",
+      "width",
+      "height",
+      "rotation",
+      "isLocked",
+      "isVisible",
+      "sortOrder"
+    ], r = [
+      "strokeColor",
+      "fillColor",
+      "strokeWidth",
+      "opacity",
+      "strokeStyle",
+      "roughness",
+      "fontSize",
+      "fontFamily"
+    ], i = e;
+    for (const c of s) {
+      const a = i[c];
+      a !== n.get(c) && n.set(c, a);
+    }
+    if (e.style)
+      for (const c of r) {
+        const a = e.style[c];
+        a !== n.get(`style.${c}`) && n.set(`style.${c}`, a);
+      }
+    const o = e.boundElements ? JSON.stringify(e.boundElements) : null;
+    switch (o !== n.get("boundElements") && n.set("boundElements", o), e.type) {
+      case "rectangle":
+        e.cornerRadius !== n.get("cornerRadius") && n.set("cornerRadius", e.cornerRadius);
+        break;
+      case "line":
+      case "arrow": {
+        const a = JSON.stringify(e.points);
+        a !== n.get("points") && n.set("points", a), e.lineType !== n.get("lineType") && n.set("lineType", e.lineType), e.curvature !== n.get("curvature") && n.set("curvature", e.curvature);
+        const l = e.startBinding ? JSON.stringify(e.startBinding) : null;
+        l !== n.get("startBinding") && n.set("startBinding", l);
+        const f = e.endBinding ? JSON.stringify(e.endBinding) : null;
+        f !== n.get("endBinding") && n.set("endBinding", f), e.type === "arrow" && (e.startArrowhead !== n.get("startArrowhead") && n.set("startArrowhead", e.startArrowhead), e.endArrowhead !== n.get("endArrowhead") && n.set("endArrowhead", e.endArrowhead));
+        break;
+      }
+      case "freedraw": {
+        const a = JSON.stringify(e.points);
+        a !== n.get("points") && n.set("points", a);
+        break;
+      }
+      case "text":
+        e.text !== n.get("text") && n.set("text", e.text), e.containerId !== n.get("containerId") && n.set("containerId", e.containerId), e.textAlign !== n.get("textAlign") && n.set("textAlign", e.textAlign), e.verticalAlign !== n.get("verticalAlign") && n.set("verticalAlign", e.verticalAlign);
+        break;
+      case "image":
+        e.src !== n.get("src") && n.set("src", e.src), e.naturalWidth !== n.get("naturalWidth") && n.set("naturalWidth", e.naturalWidth), e.naturalHeight !== n.get("naturalHeight") && n.set("naturalHeight", e.naturalHeight), e.scaleMode !== n.get("scaleMode") && n.set("scaleMode", e.scaleMode);
+        const c = e.crop ? JSON.stringify(e.crop) : null;
+        c !== n.get("crop") && n.set("crop", c), e.cornerRadius !== n.get("cornerRadius") && n.set("cornerRadius", e.cornerRadius), e.alt !== n.get("alt") && n.set("alt", e.alt);
+        break;
+    }
+  }
+  _yMapCollectionToElements(e) {
+    const n = [];
+    for (const [, s] of e.entries()) {
+      const r = j(s);
+      r && n.push(r);
+    }
+    return n.sort((s, r) => s.sortOrder && r.sortOrder ? s.sortOrder < r.sortOrder ? -1 : s.sortOrder > r.sortOrder ? 1 : 0 : 0), n;
+  }
+}
+function jn(t) {
+  const e = t.indexOf(",");
+  if (e === -1) throw new Error("Invalid data URL");
+  const s = t.slice(5, e).endsWith(";base64"), r = t.slice(e + 1);
+  let i;
+  if (s) {
+    const c = atob(r);
+    i = new Uint8Array(c.length);
+    for (let a = 0; a < c.length; a++)
+      i[a] = c.charCodeAt(a);
+  } else {
+    const c = decodeURIComponent(r);
+    i = new TextEncoder().encode(c);
+  }
+  const o = new Blob([i], { type: "application/javascript" });
+  return URL.createObjectURL(o);
+}
+function Wn(t, e) {
+  if (typeof Worker > "u") return null;
+  try {
+    const n = typeof t == "function" ? t() : t, s = n instanceof URL ? n.href : String(n);
+    if (s.startsWith("data:")) {
+      const r = jn(s);
+      return new Worker(r);
+    }
+    return new Worker(n instanceof URL ? n : s, { type: "module" });
+  } catch {
+    return null;
+  }
+}
+class is {
+  constructor(e) {
+    A(this, "_worker", null);
+    A(this, "_callbacks");
+    this._callbacks = e;
+  }
+  /**
+   * Initialize and connect the sync worker.
+   * Uses Vite's `?worker` import syntax for bundling.
+   */
+  connect(e, n) {
+    if (this.dispose(), this._worker = Wn(
+      () => "__worker_stub__"
+    ), !this._worker) {
+      this._callbacks.onStatus("disconnected");
+      return;
+    }
+    this._worker.onmessage = (s) => {
+      const r = s.data;
+      switch (r.type) {
+        case "status":
+          this._callbacks.onStatus(r.status);
+          break;
+        case "remote-update":
+          this._callbacks.onRemoteUpdate(r.elements);
+          break;
+        case "peers":
+          this._callbacks.onPeers(r.peers);
+          break;
+        case "error":
+          this._callbacks.onError(r.message);
+          break;
+      }
+    }, this._worker.onerror = (s) => {
+      this._callbacks.onError(`Worker error: ${s.message}`);
+    }, this._post({ type: "connect", config: e, syncDebounceMs: n });
+  }
+  disconnect() {
+    this._post({ type: "disconnect" });
+  }
+  sendLocalUpdate(e) {
+    this._post({ type: "local-update", elements: e });
+  }
+  sendAwareness(e) {
+    this._post({
+      type: "awareness",
+      cursor: e.cursor ?? null,
+      selectedIds: e.selectedIds,
+      activeTool: e.activeTool
+    });
+  }
+  dispose() {
+    this._worker && (this._worker.terminate(), this._worker = null);
+  }
+  _post(e) {
+    this._worker?.postMessage(e);
+  }
+}
+let gt = null;
+function zn() {
+  return gt || (gt = Promise.all([
+    Promise.resolve().then(() => Me),
+    Promise.resolve().then(() => Jn)
+  ]).then(([t, e]) => ({ yjsProvider: t, syncBridge: e }))), gt;
+}
+function os(t) {
+  const [e, n] = Tt("disconnected"), [s, r] = Tt([]), i = tt(t);
+  i.current = t;
+  const o = tt(t?.awarenessThrottleMs ?? 100), c = tt(0), a = tt(null);
+  Ae(() => {
+    if (!t) {
+      const h = a.current;
+      h && (h.yjsProvider.destroyCollaborationProvider(), h.syncBridge.stopSync()), n("disconnected"), r([]);
+      return;
+    }
+    let d = !1, m = null;
+    return zn().then((h) => {
+      if (d) return;
+      a.current = h;
+      const { createCollaborationProvider: g, onStatusChange: p, getRemoteAwareness: x, updateAwareness: w } = h.yjsProvider, { startSync: b, stopSync: I } = h.syncBridge, { provider: O } = g(t);
+      b(t.syncDebounceMs ?? 50);
+      const y = p(n), v = () => {
+        const S = x();
+        r(Array.from(S.values()));
+      };
+      O.awareness.on("change", v);
+      const _ = H.subscribe((S, B) => {
+        S.selectedIds !== B.selectedIds && w({ selectedIds: S.selectedIds }), S.activeTool !== B.activeTool && w({ activeTool: S.activeTool });
+      });
+      m = () => {
+        y(), _(), O.awareness.off("change", v), I(), h.yjsProvider.destroyCollaborationProvider();
+      };
+    }).catch((h) => {
+      n("disconnected");
+    }), () => {
+      d = !0, m && m(), n("disconnected"), r([]);
+    };
+  }, [
+    // Re-create if server/room/user changes
+    t?.serverUrl,
+    t?.roomName,
+    t?.user.id,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t?.syncDebounceMs
+  ]);
+  const l = ht((d) => {
+    const m = Date.now();
+    m - c.current < o.current || (c.current = m, a.current?.yjsProvider.updateAwareness({ cursor: d }));
+  }, []), f = ht(() => {
+    const d = a.current?.yjsProvider.getYProvider();
+    d && d.disconnect();
+  }, []), u = ht(() => {
+    const d = a.current?.yjsProvider.getYProvider();
+    d && d.connect();
+  }, []);
+  return {
+    isConnected: e === "connected",
+    connectionStatus: e,
+    peers: s,
+    disconnect: f,
+    reconnect: u,
+    updateCursor: l
+  };
+}
+const Gn = [0, 0, 0, 18, 4.5, 14.5, 9, 20, 12, 18, 7.5, 12.5, 14, 12.5, 0, 0], _t = 12, we = "system-ui, -apple-system, sans-serif", te = 6, ee = 4, ne = 14, se = 18, Y = {
+  ctx: null,
+  cache: /* @__PURE__ */ new Map()
+};
+function Vn(t) {
+  const e = Y.cache.get(t);
+  if (e !== void 0) return e;
+  if (!Y.ctx)
+    try {
+      const s = document.createElement("canvas");
+      Y.ctx = s.getContext("2d");
+    } catch {
+    }
+  let n;
+  return Y.ctx ? (Y.ctx.font = `${_t}px ${we}`, n = Y.ctx.measureText(t).width) : n = t.length * 7, Y.cache.size > 200 && Y.cache.clear(), Y.cache.set(t, n), n;
+}
+function be(t, e, n, s, r, i) {
+  const o = (t - n.x) * n.scale, c = (e - n.y) * n.scale;
+  return o >= -i && o <= s + i && c >= -i && c <= r + i;
+}
+function Zn(t, e, n, s, r) {
+  const i = t.x + t.width / 2, o = t.y + t.height / 2, c = Math.sqrt(t.width * t.width + t.height * t.height) / 2;
+  return be(i, o, e, n, s, r + c * e.scale);
+}
+const qn = ({
+  peers: t,
+  viewport: e,
+  stageWidth: n,
+  stageHeight: s,
+  elements: r
+}) => {
+  const i = Ee(() => {
+    const a = /* @__PURE__ */ new Map();
+    for (const l of r) a.set(l.id, l);
+    return a;
+  }, [r]), o = 1 / e.scale, c = 150;
+  return /* @__PURE__ */ G(ke, { children: t.map((a) => {
+    if (!a.cursor && a.selectedIds.length === 0) return null;
+    const { user: l } = a;
+    return /* @__PURE__ */ Ot(Pt, { children: [
+      a.selectedIds.map((f) => {
+        const u = i.get(f);
+        if (!u || !Zn(u, e, n, s, c))
+          return null;
+        const d = 3 * o;
+        return /* @__PURE__ */ G(
+          Bt,
+          {
+            x: u.x + u.width / 2,
+            y: u.y + u.height / 2,
+            offsetX: u.width / 2 + d,
+            offsetY: u.height / 2 + d,
+            width: u.width + d * 2,
+            height: u.height + d * 2,
+            rotation: u.rotation ?? 0,
+            stroke: l.color,
+            strokeWidth: 2 * o,
+            dash: [6 * o, 4 * o],
+            cornerRadius: 3 * o,
+            listening: !1,
+            perfectDrawEnabled: !1
+          },
+          f
+        );
+      }),
+      a.cursor && be(
+        a.cursor.x,
+        a.cursor.y,
+        e,
+        n,
+        s,
+        c
+      ) && /* @__PURE__ */ Ot(
+        Pt,
+        {
+          x: a.cursor.x,
+          y: a.cursor.y,
+          scaleX: o,
+          scaleY: o,
+          listening: !1,
+          children: [
+            /* @__PURE__ */ G(
+              Te,
+              {
+                points: Gn,
+                fill: l.color,
+                stroke: "#ffffff",
+                strokeWidth: 1,
+                closed: !0,
+                perfectDrawEnabled: !1
+              }
+            ),
+            /* @__PURE__ */ G(
+              Bt,
+              {
+                x: ne,
+                y: se,
+                width: Vn(l.name) + te * 2,
+                height: _t + ee * 2,
+                fill: l.color,
+                cornerRadius: 4,
+                listening: !1,
+                perfectDrawEnabled: !1
+              }
+            ),
+            /* @__PURE__ */ G(
+              Oe,
+              {
+                x: ne + te,
+                y: se + ee,
+                text: l.name,
+                fontSize: _t,
+                fontFamily: we,
+                fill: "#ffffff",
+                listening: !1,
+                perfectDrawEnabled: !1
+              }
+            )
+          ]
+        }
+      )
+    ] }, l.id);
+  }) });
+}, cs = Se.memo(qn);
+export {
+  rs as CollaborationManager,
+  cs as CursorOverlay,
+  kt as STYLE_FIELDS,
+  pe as SYNC_FIELDS,
+  is as SyncWorkerAdapter,
+  Pe as createCollaborationProvider,
+  ie as destroyCollaborationProvider,
+  ut as elementToYMap,
+  Xe as getRemoteAwareness,
+  oe as getYDoc,
+  ce as getYElements,
+  Be as getYProvider,
+  Ce as isCollaborationActive,
+  Ye as onStatusChange,
+  Fn as startSync,
+  xe as stopSync,
+  Le as updateAwareness,
+  os as useCollaboration,
+  j as yMapToElement
+};