y-mxgraph 0.1.1

package/y-mxgraph.es.js

@@ -0,0 +1,1509 @@
+import { xml2js, js2xml } from "xml-js";
+import * as Y from "yjs";
+import { throttle } from "lodash-es";
+import { colord } from "colord";
+function deepProcess(node) {
+  if (node == null)
+    return;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      deepProcess(item);
+    }
+    return;
+  }
+  if (typeof node !== "object")
+    return;
+  const obj = node;
+  const keys = Object.keys(obj);
+  for (const key2 of keys) {
+    if (key2 === "_attributes")
+      continue;
+    let value = obj[key2];
+    const keyLower = key2.toLowerCase();
+    if ((keyLower === "diagram" || keyLower === "mxcell") && value !== void 0 && !Array.isArray(value)) {
+      obj[key2] = [value];
+      value = obj[key2];
+    }
+    if (Array.isArray(value)) {
+      for (const v of value)
+        deepProcess(v);
+    } else if (value && typeof value === "object") {
+      deepProcess(value);
+    }
+  }
+}
+function parse$4(xml) {
+  const result = xml2js(xml, { compact: true });
+  deepProcess(result);
+  return result;
+}
+function serializer$1(obj, spaces = 2) {
+  return js2xml(obj, {
+    compact: true,
+    spaces
+  });
+}
+const key$3 = "mxCell";
+const mxGeometryKey = "mxGeometry";
+const mxGeometryAttributeKey = "geometry";
+function parse$3(object) {
+  var _a;
+  const xmlElement = new Y.XmlElement("mxCell");
+  for (const attribute of Object.keys(object._attributes || {})) {
+    xmlElement.setAttribute(
+      attribute,
+      `${((_a = object._attributes) == null ? void 0 : _a[attribute]) || ""}`
+    );
+  }
+  if (object[mxGeometryKey]) {
+    const geometry = object[mxGeometryKey];
+    const geometryString = js2xml(geometry, {
+      compact: true
+    });
+    xmlElement.setAttribute(mxGeometryAttributeKey, geometryString);
+    delete object[mxGeometryKey];
+  }
+  return xmlElement;
+}
+function serialize$2(xmlElement) {
+  const attributes = {
+    ...xmlElement.getAttributes()
+  };
+  let mxGeometry = null;
+  if (mxGeometryAttributeKey in attributes) {
+    const mxGeometryString = attributes[mxGeometryAttributeKey];
+    try {
+      const parsed = xml2js(mxGeometryString, { compact: true });
+      mxGeometry = parsed[mxGeometryKey] ?? null;
+      if (mxGeometry && mxGeometry._attributes) {
+        mxGeometry._attributes["as"] = "geometry";
+      }
+    } catch (e) {
+      console.warn("[y-mxgraph] Failed to parse mxGeometry:", e);
+    }
+    delete attributes[mxGeometryAttributeKey];
+  }
+  const obj = {
+    _attributes: attributes
+  };
+  if (mxGeometry) {
+    obj[mxGeometryKey] = mxGeometry;
+  }
+  return obj;
+}
+const key$2 = "mxGraphModel";
+const mxCellOrderKey = key$3 + "Order";
+function parse$2(object, doc) {
+  const mxCells = (object.root[key$3] || []).map((cell) => {
+    var _a;
+    return {
+      value: parse$3(cell),
+      id: ((_a = cell._attributes) == null ? void 0 : _a.id) || ""
+    };
+  });
+  const mxGraphElement = (doc == null ? void 0 : doc.getMap(key$2)) || new Y.Map();
+  const cells = new Y.Map();
+  const cellsOrder = new Y.Array();
+  mxCells.forEach((cell) => {
+    cells.set(cell.id, cell.value);
+  });
+  cellsOrder.push(mxCells.map((cell) => cell.id));
+  mxGraphElement.set(key$3, cells);
+  mxGraphElement.set(mxCellOrderKey, cellsOrder);
+  return mxGraphElement;
+}
+function serialize$1(map) {
+  const cells = map.get(key$3);
+  const cellsOrder = map.get(mxCellOrderKey);
+  return {
+    _attributes: {},
+    root: {
+      [key$3]: cellsOrder.toArray().map((id) => serialize$2(cells.get(id)))
+    }
+  };
+}
+const key$1 = "diagram";
+function parse$1(object) {
+  var _a, _b;
+  const yDiagramElement = new Y.Map();
+  yDiagramElement.set("name", `${((_a = object._attributes) == null ? void 0 : _a.name) || ""}`);
+  yDiagramElement.set("id", `${((_b = object._attributes) == null ? void 0 : _b.id) || ""}`);
+  const mxGraphModel = parse$2(object[key$2]);
+  yDiagramElement.set(key$2, mxGraphModel);
+  return yDiagramElement;
+}
+function serialize(yDiagram) {
+  const mxGraphModel = yDiagram.get(key$2);
+  return {
+    _attributes: {
+      name: yDiagram.get("name"),
+      id: yDiagram.get("id")
+    },
+    [key$2]: mxGraphModel ? serialize$1(mxGraphModel) : void 0
+  };
+}
+const key = "mxfile";
+const diagramOrderKey = key$1 + "Order";
+function parse(object, doc) {
+  var _a;
+  const mxfile = doc.getMap(key);
+  mxfile.set("pages", (((_a = object._attributes) == null ? void 0 : _a.pages) || "1") + "");
+  const diagramList = object.diagram.map((diagram) => {
+    var _a2;
+    return {
+      value: parse$1(diagram),
+      id: ((_a2 = diagram._attributes) == null ? void 0 : _a2.id) || ""
+    };
+  });
+  const diagramMap = new Y.Map();
+  const diagramOrder = new Y.Array();
+  diagramList.forEach((diagram) => {
+    diagramMap.set(diagram.id, diagram.value);
+  });
+  diagramOrder.push(diagramList.map((diagram) => diagram.id));
+  mxfile.set(key$1, diagramMap);
+  mxfile.set(diagramOrderKey, diagramOrder);
+  return mxfile;
+}
+function serializer(yMxFile) {
+  const diagrams = yMxFile.get(key$1);
+  const diagramOrder = yMxFile.get(
+    diagramOrderKey
+  );
+  const obj = {
+    _attributes: {
+      pages: yMxFile.get("pages") || "1"
+    },
+    [key$1]: diagramOrder.map((id) => diagrams.get(id)).map((diagramElement) => serialize(diagramElement))
+  };
+  return obj;
+}
+const DIFF_INSERT = "i";
+const DIFF_REMOVE = "r";
+const DIFF_UPDATE = "u";
+const docSnapshots = /* @__PURE__ */ new WeakMap();
+function insertAfterUnique(orderArr, id, previous, fallbackToEnd = false) {
+  const currentIds = orderArr.toArray();
+  let anchorPos = previous ? currentIds.indexOf(previous) : -1;
+  if (anchorPos === -1 && fallbackToEnd)
+    anchorPos = currentIds.length - 1;
+  let targetIndex = anchorPos + 1;
+  const existingIndex = currentIds.indexOf(id);
+  if (existingIndex === -1) {
+    orderArr.insert(targetIndex, [id]);
+    return;
+  }
+  if (existingIndex === targetIndex)
+    return;
+  if (existingIndex < targetIndex)
+    targetIndex -= 1;
+  orderArr.delete(existingIndex, 1);
+  orderArr.insert(targetIndex, [id]);
+}
+function ensureUniqueOrder(orderArr) {
+  const arr = orderArr.toArray();
+  const seen = /* @__PURE__ */ new Set();
+  const dupIdx = [];
+  for (let i = 0; i < arr.length; i++) {
+    const id = arr[i];
+    if (!id)
+      continue;
+    if (seen.has(id))
+      dupIdx.push(i);
+    else
+      seen.add(id);
+  }
+  if (dupIdx.length) {
+    dupIdx.sort((a, b) => b - a).forEach((idx) => orderArr.delete(idx, 1));
+  }
+}
+function applyFilePatch(doc, patch, options) {
+  doc.transact(() => {
+    const mxfile = doc.getMap(key);
+    if (patch[DIFF_REMOVE]) {
+      const diagramsMap = mxfile.get(key$1);
+      const orderArr = mxfile.get(
+        diagramOrderKey
+      );
+      ensureUniqueOrder(orderArr);
+      const orderList = orderArr.toArray();
+      const removeIds = patch[DIFF_REMOVE];
+      if (removeIds && removeIds.length) {
+        const indexList = removeIds.map((id) => orderList.indexOf(id)).filter((i) => i !== -1).sort((a, b) => b - a);
+        indexList.forEach((idx) => orderArr.delete(idx, 1));
+        removeIds.forEach((id) => diagramsMap.delete(id));
+      }
+    }
+    if (patch[DIFF_INSERT]) {
+      const diagramsMap = mxfile.get(key$1);
+      const orderArr = mxfile.get(
+        diagramOrderKey
+      );
+      ensureUniqueOrder(orderArr);
+      const existingIds = orderArr.toArray();
+      const existingIndex = /* @__PURE__ */ new Map();
+      existingIds.forEach((id, idx) => existingIndex.set(id, idx));
+      const inserts = patch[DIFF_INSERT].map((item, order) => {
+        const object = parse$4(item.data);
+        const diagramObj = Array.isArray(object == null ? void 0 : object.diagram) ? object.diagram[0] : object == null ? void 0 : object.diagram;
+        const diagramElement = parse$1(
+          diagramObj
+        );
+        return {
+          id: item.id,
+          previous: item.previous || "",
+          diagramElement,
+          order
+        };
+      });
+      const byId = new Map(inserts.map((i) => [i.id, i]));
+      const computeAnchor = (node) => {
+        let depth = 1;
+        let anchorId = "";
+        let prevId = node.previous;
+        const seen = /* @__PURE__ */ new Set([node.id]);
+        while (prevId) {
+          if (seen.has(prevId)) {
+            depth = 1;
+            anchorId = "";
+            break;
+          }
+          seen.add(prevId);
+          const prevNode = byId.get(prevId);
+          if (prevNode) {
+            depth += 1;
+            prevId = prevNode.previous;
+            continue;
+          }
+          if (existingIndex.has(prevId)) {
+            anchorId = prevId;
+          } else {
+            anchorId = "";
+          }
+          break;
+        }
+        return { anchorId, depth };
+      };
+      const enriched = inserts.map((i) => ({ ...i, ...computeAnchor(i) }));
+      enriched.sort((a, b) => {
+        const aIdx = a.anchorId ? existingIndex.get(a.anchorId) : -1;
+        const bIdx = b.anchorId ? existingIndex.get(b.anchorId) : -1;
+        if (aIdx !== bIdx)
+          return aIdx - bIdx;
+        if (a.depth !== b.depth)
+          return b.depth - a.depth;
+        return b.order - a.order;
+      });
+      for (const item of enriched) {
+        diagramsMap.set(item.id, item.diagramElement);
+        insertAfterUnique(orderArr, item.id, item.anchorId || null);
+      }
+    }
+    if (patch[DIFF_UPDATE]) {
+      Object.keys(patch[DIFF_UPDATE]).forEach((id) => {
+        const diagramsMap = mxfile.get(
+          key$1
+        );
+        const diagram = diagramsMap.get(id);
+        if (diagram) {
+          const update = patch[DIFF_UPDATE][id];
+          if ("name" in update) {
+            diagram.set(
+              "name",
+              update.name || ""
+            );
+          }
+          if (update.cells) {
+            const yMxGraphModel = diagram.get(key$2);
+            if (!yMxGraphModel)
+              return;
+            const cellsMap = yMxGraphModel.get(key$3);
+            const orderArr = yMxGraphModel.get(mxCellOrderKey);
+            if (!cellsMap || !orderArr)
+              return;
+            ensureUniqueOrder(orderArr);
+            if (update.cells[DIFF_REMOVE] && update.cells[DIFF_REMOVE].length) {
+              const orderIds = orderArr.toArray();
+              const removeIndexList = update.cells[DIFF_REMOVE].map(
+                (cid) => orderIds.indexOf(cid)
+              ).filter((i) => i !== -1).sort((a, b) => b - a);
+              removeIndexList.forEach((idx) => orderArr.delete(idx, 1));
+              update.cells[DIFF_REMOVE].forEach((cid) => cellsMap.delete(cid));
+            }
+            if (update.cells[DIFF_INSERT] && update.cells[DIFF_INSERT].length) {
+              for (const item of update.cells[DIFF_INSERT]) {
+                const id2 = item["id"];
+                if (!id2)
+                  continue;
+                const xmlElement = new Y.XmlElement("mxCell");
+                Object.keys(item).forEach((key2) => {
+                  if (key2 === "previous")
+                    return;
+                  xmlElement.setAttribute(key2, item[key2]);
+                });
+                cellsMap.set(id2, xmlElement);
+                const previous = item["previous"];
+                const parent = item["parent"];
+                let anchorId = null;
+                let fallbackToEnd = true;
+                if (typeof previous !== "undefined") {
+                  if (previous === "") {
+                    if (parent) {
+                      anchorId = parent;
+                      fallbackToEnd = true;
+                    } else {
+                      anchorId = null;
+                      fallbackToEnd = false;
+                    }
+                  } else {
+                    anchorId = previous;
+                    fallbackToEnd = true;
+                  }
+                } else if (parent) {
+                  anchorId = parent;
+                  fallbackToEnd = true;
+                }
+                insertAfterUnique(
+                  orderArr,
+                  id2,
+                  anchorId,
+                  fallbackToEnd
+                );
+              }
+            }
+            if (update.cells[DIFF_UPDATE]) {
+              Object.keys(update.cells[DIFF_UPDATE]).forEach((cid) => {
+                const updateObj = update.cells[DIFF_UPDATE][cid];
+                const cell = cellsMap.get(cid);
+                if (cell) {
+                  Object.keys(updateObj).forEach((k) => {
+                    if (k === "previous")
+                      return;
+                    cell.setAttribute(k, updateObj[k]);
+                  });
+                }
+              });
+              Object.keys(update.cells[DIFF_UPDATE]).forEach((cellId) => {
+                const updateObj = update.cells[DIFF_UPDATE][cellId];
+                const hasPrev = "previous" in updateObj;
+                const hasParent = "parent" in updateObj;
+                if (!hasPrev && !hasParent)
+                  return;
+                const prevVal = hasPrev ? updateObj.previous : void 0;
+                const parentVal = hasParent ? updateObj.parent : void 0;
+                let anchorId = null;
+                let fallbackToEnd = true;
+                if (hasPrev) {
+                  if (prevVal === "") {
+                    if (parentVal) {
+                      anchorId = parentVal;
+                      fallbackToEnd = true;
+                    } else {
+                      anchorId = null;
+                      fallbackToEnd = false;
+                    }
+                  } else {
+                    anchorId = prevVal;
+                    fallbackToEnd = true;
+                  }
+                } else if (parentVal) {
+                  anchorId = parentVal;
+                  fallbackToEnd = true;
+                }
+                const currentIds = orderArr.toArray();
+                const currentIndex = currentIds.indexOf(cellId);
+                if (currentIndex === -1) {
+                  let newCell = cellsMap.get(cellId);
+                  if (!newCell) {
+                    newCell = new Y.XmlElement("mxCell");
+                    newCell.setAttribute("id", cellId);
+                    Object.keys(updateObj).forEach((k) => {
+                      if (k === "previous")
+                        return;
+                      newCell.setAttribute(k, updateObj[k]);
+                    });
+                    cellsMap.set(cellId, newCell);
+                  }
+                  insertAfterUnique(
+                    orderArr,
+                    cellId,
+                    anchorId,
+                    fallbackToEnd
+                  );
+                  return;
+                }
+                insertAfterUnique(
+                  orderArr,
+                  cellId,
+                  anchorId,
+                  fallbackToEnd
+                );
+              });
+            }
+          }
+          if ("previous" in update) {
+            const previous = update.previous || null;
+            const orderArr = mxfile.get(
+              diagramOrderKey
+            );
+            ensureUniqueOrder(orderArr);
+            insertAfterUnique(orderArr, id, previous, false);
+          }
+        }
+      });
+    }
+  }, options == null ? void 0 : options.origin);
+}
+function initDocSnapshot(doc, resetSnapshot = false) {
+  try {
+    const mxfile = doc.getMap(key);
+    const diagramsMap = mxfile.get(key$1);
+    const orderArr = mxfile.get(diagramOrderKey);
+    const diagramOrder = resetSnapshot ? [] : orderArr ? orderArr.toArray().slice() : [];
+    const snap = {
+      diagramOrder,
+      cellsOrder: /* @__PURE__ */ new Map(),
+      cellAttrs: /* @__PURE__ */ new Map()
+    };
+    const diagrams = diagramOrder.map((id) => diagramsMap.get(id)).filter((d) => !!d);
+    for (const d of diagrams) {
+      const did = d.get("id") || "";
+      if (!did)
+        continue;
+      const gm = d.get(key$2);
+      if (gm) {
+        const order = gm.get(mxCellOrderKey);
+        const ids = order ? order.toArray().slice() : [];
+        snap.cellsOrder.set(did, ids);
+        const cellsMap = gm.get(key$3);
+        const attrMap = /* @__PURE__ */ new Map();
+        if (cellsMap) {
+          for (const cid of ids) {
+            const el = cellsMap.get(cid);
+            if (el) {
+              attrMap.set(
+                cid,
+                el.getAttributes() || {}
+              );
+            }
+          }
+        }
+        snap.cellAttrs.set(did, attrMap);
+      } else {
+        snap.cellsOrder.set(did, []);
+        snap.cellAttrs.set(did, /* @__PURE__ */ new Map());
+      }
+    }
+    docSnapshots.set(doc, snap);
+  } catch (e) {
+    console.warn("[y-mxgraph] initDocSnapshot failed:", e);
+  }
+}
+function generatePatch(events, explicitDoc) {
+  var _a, _b;
+  const patch = {};
+  const doc = explicitDoc ?? ((_b = (_a = events[0]) == null ? void 0 : _a.transaction) == null ? void 0 : _b.doc);
+  if (!doc)
+    return patch;
+  if (!explicitDoc && (!events || events.length === 0))
+    return patch;
+  const mxfile = doc.getMap(key);
+  const diagramsMap = mxfile.get(key$1);
+  const orderArr = mxfile.get(diagramOrderKey);
+  let snap = docSnapshots.get(doc);
+  if (!snap) {
+    snap = {
+      diagramOrder: null,
+      cellsOrder: /* @__PURE__ */ new Map(),
+      cellAttrs: /* @__PURE__ */ new Map()
+    };
+    docSnapshots.set(doc, snap);
+  }
+  const prevDiagramOrder = snap.diagramOrder;
+  const prevCellsOrder = snap.cellsOrder;
+  const prevCellsAttrs = snap.cellAttrs;
+  const ensureUpdate = (diagramId) => {
+    patch[DIFF_UPDATE] = patch[DIFF_UPDATE] || {};
+    patch[DIFF_UPDATE][diagramId] = patch[DIFF_UPDATE][diagramId] || {};
+    return patch[DIFF_UPDATE][diagramId];
+  };
+  const ensureCellSection = (diagramId) => {
+    const u = ensureUpdate(diagramId);
+    u.cells = u.cells || {};
+    return u.cells;
+  };
+  const currDiagramOrder = orderArr.toArray();
+  const diagramsList = currDiagramOrder.map((id) => diagramsMap.get(id)).filter((d) => !!d);
+  const currCellsOrder = /* @__PURE__ */ new Map();
+  const cellAttrMap = /* @__PURE__ */ new Map();
+  for (const d of diagramsList) {
+    const did = d.get("id") || "";
+    const attrs = /* @__PURE__ */ new Map();
+    const gm = d.get(key$2);
+    if (gm) {
+      const cellsMap = gm.get(key$3);
+      const orderArr2 = gm.get(mxCellOrderKey);
+      if (cellsMap && orderArr2) {
+        const ids = orderArr2.toArray();
+        currCellsOrder.set(did, ids);
+        for (const cid of ids) {
+          const c = cellsMap.get(cid);
+          if (c)
+            attrs.set(cid, c.getAttributes() || {});
+        }
+      } else {
+        currCellsOrder.set(did, []);
+      }
+    } else {
+      currCellsOrder.set(did, []);
+    }
+    cellAttrMap.set(did, attrs);
+  }
+  const insertedDiagramIdGlobal = /* @__PURE__ */ new Set();
+  const insertedCellIdGlobal = /* @__PURE__ */ new Set();
+  if (prevDiagramOrder) {
+    const prevSet = new Set(prevDiagramOrder);
+    const currSet = new Set(currDiagramOrder);
+    const removed = prevDiagramOrder.filter(
+      (id) => !currSet.has(id) && id
+    );
+    if (removed.length)
+      patch[DIFF_REMOVE] = removed;
+    const removedDiagramSet = new Set(removed);
+    const inserted = currDiagramOrder.filter(
+      (id) => !prevSet.has(id) && id
+    );
+    if (inserted.length) {
+      patch[DIFF_INSERT] = patch[DIFF_INSERT] || [];
+      for (const id of inserted) {
+        const index = currDiagramOrder.indexOf(id);
+        const previous = index <= 0 ? "" : currDiagramOrder[index - 1];
+        const yDiagram = diagramsMap.get(id);
+        if (!yDiagram)
+          continue;
+        const data = serializer$1({ diagram: serialize(yDiagram) });
+        patch[DIFF_INSERT].push({ id, previous, data });
+        insertedDiagramIdGlobal.add(id);
+      }
+    }
+    const prevNeighbor = (order, id) => {
+      const i = order.indexOf(id);
+      return i <= 0 ? "" : order[i - 1];
+    };
+    const common = currDiagramOrder.filter((id) => prevSet.has(id) && id);
+    for (const id of common) {
+      const prevP = prevNeighbor(prevDiagramOrder, id);
+      const currP = prevNeighbor(currDiagramOrder, id);
+      if (prevP !== currP) {
+        if (prevP && removedDiagramSet.has(prevP))
+          continue;
+        const u = ensureUpdate(id);
+        u.previous = currP;
+      }
+    }
+  }
+  const allDiagramIds = /* @__PURE__ */ new Set([
+    ...prevDiagramOrder || [],
+    ...currDiagramOrder
+  ]);
+  for (const did of allDiagramIds) {
+    if (!did)
+      continue;
+    const prevCells = prevCellsOrder.get(did) || [];
+    const currCells = currCellsOrder.get(did) || [];
+    if (!prevCells.length && !currCells.length)
+      continue;
+    const prevSet = new Set(prevCells);
+    const currSet = new Set(currCells);
+    const removed = prevCells.filter((cid) => !currSet.has(cid) && cid);
+    if (removed.length) {
+      const cells = ensureCellSection(did);
+      cells[DIFF_REMOVE] = (cells[DIFF_REMOVE] || []).concat(removed);
+    }
+    const removedCellSet = new Set(removed);
+    const inserted = currCells.filter(
+      (cid) => !prevSet.has(cid) && cid
+    );
+    if (inserted.length) {
+      const cells = ensureCellSection(did);
+      cells[DIFF_INSERT] = cells[DIFF_INSERT] || [];
+      const attrsMap = cellAttrMap.get(did) || /* @__PURE__ */ new Map();
+      for (const cid of inserted) {
+        const attrs = attrsMap.get(cid) || {};
+        const index = currCells.indexOf(cid);
+        const previous = index <= 0 ? "" : currCells[index - 1];
+        cells[DIFF_INSERT].push({
+          ...attrs,
+          previous
+        });
+        insertedCellIdGlobal.add(cid);
+      }
+    }
+    const prevNeighbor = (order, id) => {
+      const i = order.indexOf(id);
+      return i <= 0 ? "" : order[i - 1];
+    };
+    const commonCells = currCells.filter((cid) => prevSet.has(cid) && cid);
+    for (const cid of commonCells) {
+      const prevP = prevNeighbor(prevCells, cid);
+      const currP = prevNeighbor(currCells, cid);
+      if (prevP !== currP) {
+        if (prevP && removedCellSet.has(prevP))
+          continue;
+        const cells = ensureCellSection(did);
+        cells[DIFF_UPDATE] = cells[DIFF_UPDATE] || {};
+        const cellUpdate = cells[DIFF_UPDATE][cid] = cells[DIFF_UPDATE][cid] || {};
+        cellUpdate.previous = currP;
+      }
+    }
+  }
+  {
+    const diagramSet = new Set(
+      diagramsList
+    );
+    for (const ev of events) {
+      const target = ev.target;
+      if (!(target instanceof Y.Map))
+        continue;
+      if (!diagramSet.has(target))
+        continue;
+      const changed = ev.keysChanged || /* @__PURE__ */ new Set();
+      if (!changed || !changed.has("name"))
+        continue;
+      const did = target.get("id") || "";
+      if (!did || insertedDiagramIdGlobal.has(did))
+        continue;
+      const u = ensureUpdate(did);
+      u.name = target.get("name") || "";
+    }
+  }
+  if (!prevDiagramOrder) {
+    for (const d of diagramsList) {
+      const did = d.get("id") || "";
+      if (!did)
+        continue;
+      const u = ensureUpdate(did);
+      u.name = d.get("name") || "";
+    }
+  }
+  for (const ev of events) {
+    const target = ev.target;
+    if (!(target instanceof Y.XmlElement))
+      continue;
+    const el = target;
+    if (el.nodeName !== "mxCell")
+      continue;
+    const changed = ev.attributesChanged || ev.keysChanged || /* @__PURE__ */ new Set();
+    if (!changed || changed.size === 0)
+      continue;
+    const cellId = el.getAttribute("id");
+    if (!cellId || insertedCellIdGlobal.has(cellId))
+      continue;
+    const idsEntries = Array.from(currCellsOrder.entries());
+    let diagramId = "";
+    for (const [did, ids] of idsEntries) {
+      if (ids.includes(cellId)) {
+        diagramId = did;
+        break;
+      }
+    }
+    if (!diagramId)
+      continue;
+    const cellsPatch = ensureCellSection(diagramId);
+    cellsPatch[DIFF_UPDATE] = cellsPatch[DIFF_UPDATE] || {};
+    const cellUpdate = cellsPatch[DIFF_UPDATE][cellId] = cellsPatch[DIFF_UPDATE][cellId] || {};
+    for (const key2 of Array.from(changed)) {
+      cellUpdate[key2] = el.getAttribute(key2) || "";
+    }
+  }
+  if (prevDiagramOrder) {
+    for (const [did, currAttrsMap] of cellAttrMap.entries()) {
+      const prevAttrsMap = prevCellsAttrs.get(did) || /* @__PURE__ */ new Map();
+      const cellsPatch = ensureCellSection(did);
+      cellsPatch[DIFF_UPDATE] = cellsPatch[DIFF_UPDATE] || {};
+      const updateBucket = cellsPatch[DIFF_UPDATE];
+      const currCells = currAttrsMap.keys();
+      for (const cid of currCells) {
+        if (insertedCellIdGlobal.has(cid))
+          continue;
+        const prevAttrs = prevAttrsMap.get(cid) || {};
+        const currAttrs = currAttrsMap.get(cid) || {};
+        const keys = /* @__PURE__ */ new Set([
+          ...Object.keys(prevAttrs),
+          ...Object.keys(currAttrs)
+        ]);
+        const cellUpdate = updateBucket[cid] = updateBucket[cid] || {};
+        let changed = false;
+        for (const k of keys) {
+          const pv = prevAttrs[k] ?? "";
+          const cv = currAttrs[k] ?? "";
+          if (pv !== cv) {
+            cellUpdate[k] = cv;
+            changed = true;
+          }
+        }
+        if (!changed) {
+          if (Object.keys(cellUpdate).length === 0) {
+            delete updateBucket[cid];
+          }
+        }
+      }
+    }
+  }
+  snap.diagramOrder = currDiagramOrder.slice();
+  const newCellsOrder = /* @__PURE__ */ new Map();
+  const newCellsAttrs = /* @__PURE__ */ new Map();
+  for (const [did, arr] of currCellsOrder.entries()) {
+    newCellsOrder.set(did, arr.slice());
+  }
+  for (const [did, attrsMap] of cellAttrMap.entries()) {
+    const copy = /* @__PURE__ */ new Map();
+    for (const [cid, attrs] of attrsMap.entries()) {
+      copy.set(cid, { ...attrs });
+    }
+    newCellsAttrs.set(did, copy);
+  }
+  snap.cellsOrder = newCellsOrder;
+  snap.cellAttrs = newCellsAttrs;
+  docSnapshots.set(doc, snap);
+  return patch;
+}
+function xml2doc(xml, doc) {
+  const object = parse$4(xml);
+  const mxfile = object.mxfile;
+  const mxGraphModel = object.mxGraphModel;
+  if (mxfile) {
+    doc.transact(() => {
+      parse(mxfile, doc);
+    });
+  } else if (mxGraphModel) {
+    doc.transact(() => {
+      parse$2(mxGraphModel, doc);
+    });
+  } else {
+    throw new Error("不支持的文件格式");
+  }
+  return doc;
+}
+function doc2xml(doc, spaces = 0) {
+  if (doc.share.has(key)) {
+    return serializer$1(
+      {
+        [key]: serializer(
+          doc.share.get(key)
+        )
+      },
+      spaces
+    );
+  } else if (doc.share.has(key$2)) {
+    return serializer$1(
+      {
+        [key$2]: serialize$1(
+          doc.share.get(key$2)
+        )
+      },
+      spaces
+    );
+  }
+  return "";
+}
+const LOCAL_ORIGIN = {};
+function createMxEventObject(name, props) {
+  const _props = props || {};
+  return {
+    name,
+    getName: () => name,
+    getProperty: (k) => _props[k]
+  };
+}
+function bindUndoManager(doc, file, yUndo) {
+  const editor = file.getUi().editor;
+  const originUndoManager = editor.undoManager;
+  let lastTxnLocalOrigin = false;
+  const beforeTxnHandler = (t) => {
+    lastTxnLocalOrigin = !!(t.local || t.origin === LOCAL_ORIGIN);
+  };
+  const afterTxnHandler = (t) => {
+    lastTxnLocalOrigin = !!(t.local || t.origin === LOCAL_ORIGIN);
+  };
+  doc.on("beforeTransaction", beforeTxnHandler);
+  doc.on("afterTransaction", afterTxnHandler);
+  const pairs = [];
+  const raw = Array.isArray(originUndoManager == null ? void 0 : originUndoManager.eventListeners) ? originUndoManager.eventListeners : [];
+  for (let i = 0; i + 1 < raw.length; i += 2) {
+    const key2 = String(raw[i]);
+    const fn = raw[i + 1];
+    pairs.push([key2, fn]);
+  }
+  const mxLike = {
+    eventListeners: [],
+    history: [],
+    indexOfNextAdd: 0,
+    _y: yUndo,
+    addListener(name, fn) {
+      this.eventListeners.push(name, fn);
+    },
+    fireEvent(evt) {
+      var _a;
+      const eventName = (evt == null ? void 0 : evt.name) || (((_a = evt == null ? void 0 : evt.getName) == null ? void 0 : _a.call(evt)) ?? "");
+      for (let i = 0; i + 1 < this.eventListeners.length; i += 2) {
+        const key2 = this.eventListeners[i];
+        const listener = this.eventListeners[i + 1];
+        if (key2 === eventName) {
+          try {
+            listener(this, evt);
+          } catch (e) {
+            console.warn("[y-mxgraph] undoManager event listener error:", e);
+          }
+        }
+      }
+    },
+    clear() {
+      if (typeof this._y.clear === "function") {
+        this._y.clear();
+      } else {
+        while (this._y.canUndo && this._y.canUndo())
+          this._y.undo();
+        while (this._y.canRedo && this._y.canRedo())
+          this._y.redo();
+      }
+      this.history = [];
+      this.indexOfNextAdd = 0;
+      this.fireEvent(createMxEventObject("clear"));
+    },
+    canUndo() {
+      return typeof this._y.canUndo === "function" && this._y.canUndo();
+    },
+    canRedo() {
+      return typeof this._y.canRedo === "function" && this._y.canRedo();
+    },
+    undo() {
+      this._y.undo();
+    },
+    redo() {
+      this._y.redo();
+    },
+    undoableEditHappened() {
+    }
+  };
+  const bridgeHandlers = [];
+  const bridge = (mxEventName, yEventName) => {
+    const handler = () => {
+      if (mxEventName !== "clear" && !lastTxnLocalOrigin) {
+        return;
+      }
+      switch (mxEventName) {
+        case "add": {
+          if (mxLike.indexOfNextAdd < mxLike.history.length) {
+            mxLike.history.splice(
+              mxLike.indexOfNextAdd,
+              mxLike.history.length - mxLike.indexOfNextAdd
+            );
+          }
+          mxLike.history.push({});
+          mxLike.indexOfNextAdd = mxLike.history.length;
+          break;
+        }
+        case "clear": {
+          mxLike.history = [];
+          mxLike.indexOfNextAdd = 0;
+          break;
+        }
+      }
+      const evt = createMxEventObject(mxEventName, { edit: { changes: [] } });
+      mxLike.fireEvent(evt);
+    };
+    yUndo.on(yEventName, handler);
+    bridgeHandlers.push([yEventName, handler]);
+  };
+  bridge("add", "stack-item-added");
+  bridge("clear", "stack-cleared");
+  const poppedHandler = (e) => {
+    const t = e && (e.type || e.reason || e.kind);
+    if (t === "undo") {
+      if (mxLike.indexOfNextAdd > 0)
+        mxLike.indexOfNextAdd--;
+      const evt = createMxEventObject("undo", { edit: { changes: [] } });
+      mxLike.fireEvent(evt);
+    } else if (t === "redo") {
+      if (mxLike.indexOfNextAdd < mxLike.history.length)
+        mxLike.indexOfNextAdd++;
+      const evt = createMxEventObject("redo", { edit: { changes: [] } });
+      mxLike.fireEvent(evt);
+    }
+  };
+  yUndo.on("stack-item-popped", poppedHandler);
+  const updatedHandler = () => {
+    const evt = createMxEventObject("redo", { edit: { changes: [] } });
+    mxLike.fireEvent(evt);
+  };
+  yUndo.on("stack-item-updated", updatedHandler);
+  pairs.forEach(([key2, fn]) => {
+    const k = key2.toLowerCase();
+    if (k === "add" || k === "clear" || k === "undo" || k === "redo") {
+      mxLike.addListener(k, fn);
+    }
+  });
+  editor.undoManager = mxLike;
+  editor.undoListener = function() {
+  };
+  const destroy = () => {
+    doc.off("beforeTransaction", beforeTxnHandler);
+    doc.off("afterTransaction", afterTxnHandler);
+    bridgeHandlers.forEach(([event, handler]) => {
+      yUndo.off(event, handler);
+    });
+    yUndo.off("stack-item-popped", poppedHandler);
+    yUndo.off("stack-item-updated", updatedHandler);
+    editor.undoManager = originUndoManager;
+    editor.undoListener = originUndoManager == null ? void 0 : originUndoManager.undoListener;
+  };
+  return destroy;
+}
+function getAwarenessStateValue(awareness, key2, clientId) {
+  const states = awareness.getStates();
+  const id = clientId != null ? Number(clientId) : awareness.clientID;
+  const clientState = states.get(id);
+  if (!clientState)
+    return null;
+  if (!key2)
+    return clientState;
+  return getByPath(clientState, key2);
+}
+function getByPath(obj, path) {
+  const parts = path.split(".");
+  let cur = obj;
+  for (const part of parts) {
+    if (cur == null)
+      return null;
+    const key2 = Array.isArray(cur) && /^\d+$/.test(part) ? Number(part) : part;
+    cur = cur == null ? void 0 : cur[key2];
+  }
+  return cur;
+}
+function setAwarenessStateValue(awareness, key2, value, clientId) {
+  const id = clientId != null ? Number(clientId) : awareness.clientID;
+  if (id !== awareness.clientID)
+    return false;
+  if (!key2) {
+    awareness.setLocalState(value);
+    return true;
+  }
+  const current = awareness.getLocalState() || {};
+  const next = setByPath(current, key2, value);
+  awareness.setLocalState(next);
+  return true;
+}
+function setByPath(obj, path, value) {
+  const parts = path.split(".");
+  const root = Array.isArray(obj) ? obj.slice() : { ...obj };
+  let cur = root;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const isIndex = /^\d+$/.test(part);
+    const key2 = isIndex ? Number(part) : part;
+    const isLast = i === parts.length - 1;
+    if (isLast) {
+      cur[key2] = value;
+    } else {
+      let next = cur[key2];
+      const nextIsIndex = /^\d+$/.test(parts[i + 1]);
+      if (next == null) {
+        next = nextIsIndex ? [] : {};
+      } else {
+        next = Array.isArray(next) ? next.slice() : { ...next };
+      }
+      cur[key2] = next;
+      cur = next;
+    }
+  }
+  return root;
+}
+function generateColor(seed) {
+  const hash = hashString(String(seed || Math.random()));
+  const h = hash % 360;
+  const s = 65 + (hash >>> 8) % 20;
+  const l = 55 + (hash >>> 16) % 10;
+  return hslToHex(h, s, l);
+}
+function generateRandomName() {
+  const len = 6;
+  const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(len);
+    crypto.getRandomValues(bytes);
+    for (let i = 0; i < len; i++) {
+      id += alphabet[bytes[i] % alphabet.length];
+    }
+  } else {
+    for (let i = 0; i < len; i++) {
+      id += alphabet[Math.floor(Math.random() * alphabet.length)];
+    }
+  }
+  return id;
+}
+function hashString(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash ^ str.charCodeAt(i);
+  }
+  return hash >>> 0;
+}
+function hslToHex(h, s, l) {
+  s /= 100;
+  l /= 100;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const hp = h / 60;
+  const x = c * (1 - Math.abs(hp % 2 - 1));
+  let r1 = 0, g1 = 0, b1 = 0;
+  if (hp >= 0 && hp < 1)
+    [r1, g1, b1] = [c, x, 0];
+  else if (hp >= 1 && hp < 2)
+    [r1, g1, b1] = [x, c, 0];
+  else if (hp >= 2 && hp < 3)
+    [r1, g1, b1] = [0, c, x];
+  else if (hp >= 3 && hp < 4)
+    [r1, g1, b1] = [0, x, c];
+  else if (hp >= 4 && hp < 5)
+    [r1, g1, b1] = [x, 0, c];
+  else
+    [r1, g1, b1] = [c, 0, x];
+  const m = l - c / 2;
+  const r = Math.round((r1 + m) * 255);
+  const g = Math.round((g1 + m) * 255);
+  const b = Math.round((b1 + m) * 255);
+  return "#" + [r, g, b].map((v) => v.toString(16).padStart(2, "0")).join("");
+}
+function createCursorImage(color) {
+  const w = 8;
+  const h = 12;
+  const path = '<path d="M 4 0 L 8 12 L 4 10 L 0 12 Z" stroke="' + color + '" fill="' + color + '"/>';
+  const svg = '<svg xmlns="http://www.w3.org/2000/svg" width="' + w + 'px" height="' + h + 'px" viewBox="0 0 ' + w + " " + h + '" version="1.1">' + path + "</svg>";
+  const bytes = new Uint8Array(svg.length);
+  for (let i = 0; i < svg.length; i++) {
+    bytes[i] = svg.charCodeAt(i);
+  }
+  const encoded = btoa(String.fromCharCode.apply(null, bytes));
+  return "data:image/svg+xml;base64," + encoded;
+}
+const CacheKey$1 = "__remoteCursor__";
+function createCursorEl(color, username) {
+  const cursor = document.createElement("div");
+  cursor.style.position = "absolute";
+  cursor.style.opacity = "0.9";
+  cursor.style.transition = "all 0.3s ease-in-out";
+  const img = document.createElement("img");
+  img.style.transform = "rotate(-45deg) translateX(-14px)";
+  img.setAttribute("src", createCursorImage(color));
+  img.style.width = "10px";
+  img.style.transition = "all 0.3s ease-in-out";
+  cursor.appendChild(img);
+  const name = document.createElement("div");
+  name.style.backgroundColor = color;
+  name.style.color = colord(color).isDark() ? "#fff" : "#000";
+  name.style.fontSize = "9pt";
+  name.style.padding = "3px 7px";
+  name.style.marginTop = "8px";
+  name.style.borderRadius = "10px";
+  name.style.maxWidth = "100px";
+  name.style.overflow = "hidden";
+  name.style.textOverflow = "ellipsis";
+  name.style.whiteSpace = "nowrap";
+  name.innerText = username;
+  cursor.appendChild(name);
+  return cursor;
+}
+function bindCursor(file, options) {
+  const graph = options.graph || file.getUi().editor.graph;
+  const awareness = options.awareness;
+  const mouseMoveThrottle = options.mouseMoveThrottle ?? 100;
+  const listener = {
+    startX: 0,
+    startY: 0,
+    scrollLeft: 0,
+    scrollTop: 0,
+    mouseDown: function() {
+    },
+    mouseUp: function() {
+    },
+    mouseMove: throttle(function(_sender, event) {
+      var _a;
+      const containerRect = graph.container.getBoundingClientRect();
+      const { translate, scale } = graph.view;
+      const x = Math.round(
+        (event.evt.clientX - containerRect.x + graph.container.scrollLeft) / scale - translate.x
+      );
+      const y = Math.round(
+        (event.evt.clientY - containerRect.y + graph.container.scrollTop) / scale - translate.y
+      );
+      awareness.setLocalStateField("cursor", {
+        x,
+        y,
+        pageId: (_a = file.getUi().currentPage) == null ? void 0 : _a.getId()
+      });
+    }, mouseMoveThrottle)
+  };
+  graph.addMouseListener(listener);
+  const handleMouseLeave = () => {
+    var _a;
+    awareness.setLocalStateField("cursor", {
+      x: 0,
+      y: 0,
+      pageId: (_a = file.getUi().currentPage) == null ? void 0 : _a.getId(),
+      hide: true
+    });
+  };
+  graph.container.addEventListener("mouseleave", handleMouseLeave);
+  return () => {
+    graph.removeMouseListener(listener);
+    graph.container.removeEventListener("mouseleave", handleMouseLeave);
+  };
+}
+function renderRemoteCursors(ui, remotes) {
+  var _a;
+  if (!(CacheKey$1 in ui)) {
+    ui[CacheKey$1] = /* @__PURE__ */ new Map();
+  }
+  const cache = ui[CacheKey$1];
+  const currentPageId = (_a = ui.currentPage) == null ? void 0 : _a.getId();
+  if (!currentPageId) {
+    Array.from(cache.values()).forEach((el) => el.remove());
+    cache.clear();
+    return;
+  }
+  const currentPageRemotes = [];
+  const otherPageRemotes = [];
+  const leaveRemotesIds = /* @__PURE__ */ new Set();
+  Array.from(cache.keys()).forEach((clientId) => {
+    if (!remotes.has(clientId))
+      leaveRemotesIds.add(clientId);
+  });
+  Array.from(remotes.values()).forEach((remote) => {
+    var _a2;
+    if (((_a2 = remote.cursorState) == null ? void 0 : _a2.pageId) === currentPageId) {
+      currentPageRemotes.push(remote);
+    } else {
+      otherPageRemotes.push(remote);
+    }
+  });
+  leaveRemotesIds.forEach((clientId) => {
+    const el = cache.get(clientId);
+    cache.delete(clientId);
+    if (!el)
+      return;
+    el.remove();
+  });
+  otherPageRemotes.forEach(({ clientId }) => {
+    const el = cache.get(clientId);
+    if (!el)
+      return;
+    el.remove();
+  });
+  if (!currentPageRemotes.length)
+    return;
+  const graph = ui.editor.graph;
+  const { translate, scale } = graph.view;
+  currentPageRemotes.forEach(
+    ({ clientId, cursorState, userColor, userName }) => {
+      if (!cursorState)
+        return;
+      let el = cache.get(clientId);
+      if (cursorState.hide) {
+        if (el) {
+          el.remove();
+          cache.delete(clientId);
+        }
+        return;
+      }
+      if (!el) {
+        el = createCursorEl(userColor, userName);
+        ui.diagramContainer.appendChild(el);
+        cache.set(clientId, el);
+      }
+      const x = (translate.x + cursorState.x) * scale + 8;
+      const y = (translate.y + cursorState.y) * scale - 12;
+      const cx = Math.max(
+        graph.container.scrollLeft,
+        Math.min(
+          graph.container.scrollLeft + graph.container.clientWidth - el.clientWidth,
+          x
+        )
+      );
+      const cy = Math.max(
+        graph.container.scrollTop - 22,
+        Math.min(
+          graph.container.scrollTop + graph.container.clientHeight - el.clientHeight,
+          y
+        )
+      );
+      el.style.left = cx + "px";
+      el.style.top = cy + "px";
+      el.style.display = "";
+    }
+  );
+}
+function getId(item) {
+  if (item.id)
+    return item.id;
+  return null;
+}
+const SELECTION_OPACITY = 70;
+const CacheKey = "__remoteSelection__";
+function bindSelection(file, options) {
+  const graph = options.graph || file.getUi().editor.graph;
+  const awareness = options.awareness;
+  const handler = function() {
+    var _a;
+    const pageId = (_a = file.getUi().currentPage) == null ? void 0 : _a.getId();
+    const cells = graph.getSelectionModel().cells;
+    const ids = Object.keys(cells || {}).map(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (key2) => getId(cells[key2])
+    ).filter(Boolean);
+    awareness.setLocalStateField("selection", { ids, pageId });
+  };
+  const selectionModel = graph.getSelectionModel();
+  selectionModel.addListener("change", handler);
+  return () => {
+    selectionModel.removeListener("change", handler);
+  };
+}
+function renderRemoteSelections(ui, remotes) {
+  var _a;
+  if (!(CacheKey in ui)) {
+    ui[CacheKey] = /* @__PURE__ */ new Map();
+  }
+  const cache = ui[CacheKey];
+  const currentPageId = (_a = ui.currentPage) == null ? void 0 : _a.getId();
+  if (!currentPageId) {
+    cache.clear();
+    return;
+  }
+  const currentPageRemotes = [];
+  const otherPageRemotes = [];
+  const leaveRemotesIds = /* @__PURE__ */ new Set();
+  Array.from(cache.keys()).forEach((clientId) => {
+    if (!remotes.has(clientId))
+      leaveRemotesIds.add(clientId);
+  });
+  Array.from(remotes.values()).forEach((remote) => {
+    var _a2;
+    if (((_a2 = remote.selectionState) == null ? void 0 : _a2.pageId) === currentPageId) {
+      currentPageRemotes.push(remote);
+    } else {
+      otherPageRemotes.push(remote);
+    }
+  });
+  leaveRemotesIds.forEach((clientId) => {
+    const highlightCellMap = cache.get(clientId);
+    cache.delete(clientId);
+    if (!highlightCellMap)
+      return;
+    Array.from(highlightCellMap.values()).forEach((h) => h.destroy());
+    highlightCellMap.clear();
+  });
+  otherPageRemotes.forEach(({ clientId }) => {
+    const highlightCellMap = cache.get(clientId);
+    if (!highlightCellMap)
+      return;
+    Array.from(highlightCellMap.values()).forEach((h) => h.destroy());
+    highlightCellMap.clear();
+  });
+  if (!currentPageRemotes.length)
+    return;
+  const graph = ui.editor.graph;
+  currentPageRemotes.forEach(({ clientId, selectionState, userColor }) => {
+    let highlightCellMap = cache.get(clientId);
+    if (!highlightCellMap) {
+      highlightCellMap = /* @__PURE__ */ new Map();
+      cache.set(clientId, highlightCellMap);
+    }
+    const currentIds = new Set((selectionState == null ? void 0 : selectionState.ids) ?? []);
+    Array.from(highlightCellMap.keys()).forEach((id) => {
+      var _a2;
+      if (!currentIds.has(id)) {
+        (_a2 = highlightCellMap.get(id)) == null ? void 0 : _a2.destroy();
+        highlightCellMap.delete(id);
+      }
+    });
+    currentIds.forEach((id) => {
+      if (highlightCellMap.has(id))
+        return;
+      const cell = graph.model.getCell(id);
+      if (cell) {
+        const highlightCell = graph.highlightCell(
+          cell,
+          userColor,
+          6e4,
+          SELECTION_OPACITY,
+          3
+        );
+        highlightCellMap.set(id, highlightCell);
+      }
+    });
+  });
+}
+const DEFAULT_USER_NAME_KEY = "user.name";
+const DEFAULT_USER_COLOR_KEY = "user.color";
+function bindCollaborator(file, options) {
+  const graph = options.graph || file.getUi().editor.graph;
+  const awareness = options.awareness;
+  const mouseMoveThrottle = options.mouseMoveThrottle ?? 100;
+  const cursorOption = options.cursor;
+  const userNameKey = typeof cursorOption === "object" && (cursorOption == null ? void 0 : cursorOption.userNameKey) ? cursorOption.userNameKey : DEFAULT_USER_NAME_KEY;
+  const userColorKey = typeof cursorOption === "object" && (cursorOption == null ? void 0 : cursorOption.userColorKey) ? cursorOption.userColorKey : DEFAULT_USER_COLOR_KEY;
+  let userName = getAwarenessStateValue(awareness, userNameKey);
+  if (!userName) {
+    userName = generateRandomName();
+    setAwarenessStateValue(awareness, userNameKey, userName);
+  }
+  let userColor = getAwarenessStateValue(awareness, userColorKey);
+  if (!userColor) {
+    userColor = generateColor(userName);
+    setAwarenessStateValue(awareness, userColorKey, userColor);
+  }
+  const cleanupCursor = bindCursor(file, {
+    awareness,
+    graph,
+    mouseMoveThrottle
+  });
+  const cleanupSelection = bindSelection(file, {
+    awareness,
+    graph
+  });
+  const showCursor = options.cursor ?? true;
+  let cleanupAwareness;
+  if (typeof showCursor === "boolean" && showCursor) {
+    const awarenessHandler = (update) => {
+      const states = awareness.getStates();
+      const remotes = /* @__PURE__ */ new Map();
+      const changedClientIds = /* @__PURE__ */ new Set([...update.added, ...update.updated]);
+      for (const [clientId] of states.entries()) {
+        if (clientId === awareness.clientID)
+          continue;
+        if (!changedClientIds.has(clientId))
+          continue;
+        const name = getAwarenessStateValue(awareness, userNameKey, clientId) || clientId + "";
+        const color = getAwarenessStateValue(awareness, userColorKey, clientId) || "#000000";
+        remotes.set(clientId, {
+          clientId,
+          cursorState: getAwarenessStateValue(
+            awareness,
+            "cursor",
+            clientId
+          ),
+          selectionState: getAwarenessStateValue(
+            awareness,
+            "selection",
+            clientId
+          ),
+          userColor: color,
+          userName: name
+        });
+      }
+      renderRemoteCursors(file.getUi(), remotes);
+      renderRemoteSelections(file.getUi(), remotes);
+    };
+    awareness.on("update", awarenessHandler);
+    cleanupAwareness = () => awareness.off("update", awarenessHandler);
+  }
+  return () => {
+    cleanupCursor == null ? void 0 : cleanupCursor();
+    cleanupSelection == null ? void 0 : cleanupSelection();
+    cleanupAwareness == null ? void 0 : cleanupAwareness();
+  };
+}
+class Binding {
+  constructor(file, options) {
+    this.suppressLocalApply = false;
+    const { doc, awareness, undoManager, mouseMoveThrottle, cursor } = options;
+    this.doc = doc;
+    const ui = file.getUi();
+    const graph = ui.editor.graph;
+    this.mxGraphModel = graph.model;
+    const docHasData = doc.share.has(key);
+    if (!docHasData) {
+      xml2doc(file.data, doc);
+    }
+    initDocSnapshot(doc, docHasData);
+    this.mxListener = () => {
+      if (this.suppressLocalApply)
+        return;
+      const patch = file.ui.diffPages(
+        file.shadowPages,
+        file.ui.pages
+      );
+      file.setShadowPages(file.ui.clonePages(file.ui.pages));
+      applyFilePatch(doc, patch, { origin: LOCAL_ORIGIN });
+    };
+    this.mxGraphModel.addListener("change", this.mxListener);
+    this.docObserver = (events, transaction) => {
+      if (transaction.local && transaction.origin === LOCAL_ORIGIN) {
+        generatePatch(events);
+        return;
+      }
+      const patch = generatePatch(events);
+      this.suppressLocalApply = true;
+      try {
+        file.patch([patch]);
+        file.setShadowPages(file.ui.clonePages(file.ui.pages));
+      } finally {
+        this.suppressLocalApply = false;
+      }
+    };
+    doc.getMap(key).observeDeep(this.docObserver);
+    if (docHasData) {
+      const fullPatch = generatePatch([], doc);
+      if (Object.keys(fullPatch).length > 0) {
+        this.suppressLocalApply = true;
+        try {
+          file.patch([fullPatch]);
+          file.setShadowPages(file.ui.clonePages(file.ui.pages));
+        } finally {
+          this.suppressLocalApply = false;
+        }
+      }
+    }
+    if (awareness) {
+      this.cleanupCollaborator = bindCollaborator(file, {
+        awareness,
+        graph,
+        cursor: cursor ?? true,
+        mouseMoveThrottle
+      });
+    }
+    if (undoManager) {
+      this.cleanupUndoManager = bindUndoManager(doc, file, undoManager);
+    }
+  }
+  /**
+   * 销毁绑定，解除所有监听器
+   * @param deep - 是否深度清理（包括 awareness/undoManager），默认 false
+   */
+  destroy(deep = false) {
+    var _a, _b;
+    this.mxGraphModel.removeListener("change", this.mxListener);
+    this.doc.getMap(key).unobserveDeep(this.docObserver);
+    if (deep) {
+      (_a = this.cleanupCollaborator) == null ? void 0 : _a.call(this);
+      (_b = this.cleanupUndoManager) == null ? void 0 : _b.call(this);
+    }
+  }
+  /**
+   * 静态工厂方法，创建 Binding 实例
+   * 与 `new Binding()` 等价
+   */
+  static create(file, options) {
+    return new Binding(file, options);
+  }
+}
+export {
+  Binding,
+  DEFAULT_USER_COLOR_KEY,
+  DEFAULT_USER_NAME_KEY,
+  LOCAL_ORIGIN,
+  doc2xml,
+  xml2doc
+};
+//# sourceMappingURL=y-mxgraph.es.js.map