ooxml-core 1.20.0 → 1.22.0

package/dist/visio/collab/index.mjs

@@ -0,0 +1,1152 @@
+import * as Y from 'yjs';
+import JSZip from 'jszip';
+import { XMLSerializer, DOMParser } from '@xmldom/xmldom';
+
+// visio/collab/bind.ts
+var DEFAULT_XML_LIMITS = {
+  maxDepth: 512,
+  maxNodes: 5e6
+};
+var XmlLimitError = class extends Error {
+  code = "xml-limit";
+  /** The limit that was exceeded. */
+  limit;
+  /** Its value: the largest depth or element count allowed. */
+  maximum;
+  constructor(message, limit, maximum) {
+    super(message);
+    this.name = "XmlLimitError";
+    this.limit = limit;
+    this.maximum = maximum;
+  }
+};
+var TAG_RE = /<(\/?)([^\s\/><]+)(?:\s+[^\s=\/><]+\s*=\s*(?:"[^"<]*"|'[^'<]*'))*\s*(\/?)>/y;
+var MARKUP_SKIPS = [
+  ["<!--", "-->"],
+  ["<![CDATA[", "]]>"],
+  ["<?", "?>"]
+];
+function checkXmlLimits(xml, label, limits = {}) {
+  const maxDepth = limits.maxDepth ?? DEFAULT_XML_LIMITS.maxDepth;
+  const maxNodes = limits.maxNodes ?? DEFAULT_XML_LIMITS.maxNodes;
+  let depth = 0;
+  let nodes = 0;
+  let at = xml.indexOf("<");
+  while (at !== -1) {
+    const skip = MARKUP_SKIPS.find(([open]) => xml.startsWith(open, at));
+    if (skip) {
+      const end = xml.indexOf(skip[1], at + skip[0].length);
+      if (end === -1) return;
+      at = xml.indexOf("<", end + skip[1].length);
+      continue;
+    }
+    TAG_RE.lastIndex = at;
+    const match = TAG_RE.exec(xml);
+    if (!match) {
+      at = xml.indexOf("<", at + 1);
+      continue;
+    }
+    const [, closing, , selfClosing] = match;
+    at = xml.indexOf("<", at + match[0].length);
+    if (closing) {
+      depth--;
+      continue;
+    }
+    nodes++;
+    if (nodes > maxNodes)
+      throw new XmlLimitError(
+        `${label} XML exceeds the limit of ${maxNodes} elements`,
+        "maxNodes",
+        maxNodes
+      );
+    if (!selfClosing && ++depth > maxDepth)
+      throw new XmlLimitError(
+        `${label} XML exceeds the nesting depth limit of ${maxDepth}`,
+        "maxDepth",
+        maxDepth
+      );
+  }
+}
+var CRLF_DECLARATION = /^<\?xml[^>]*\?>\r\n/;
+var crlfDeclarations = /* @__PURE__ */ new WeakSet();
+function parseXml(xml, options = {}) {
+  const label = options.label ?? "OOXML";
+  if (/<!DOCTYPE|<!ENTITY/i.test(xml))
+    throw new Error(`${label} XML with DTD or entity declarations is not supported`);
+  checkXmlLimits(xml, label, options.limits);
+  let parseError = "";
+  let parsed;
+  try {
+    parsed = new DOMParser({
+      onError: (level, message) => {
+        if (level !== "warning") parseError = message;
+      }
+    }).parseFromString(xml, "application/xml");
+  } catch (error) {
+    throw new Error(
+      `Invalid ${label} XML: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+  if (parseError || !parsed.documentElement)
+    throw new Error(`Invalid ${label} XML: ${parseError || "missing root element"}`);
+  if (CRLF_DECLARATION.test(xml)) crlfDeclarations.add(parsed);
+  return parsed;
+}
+var buildXml = (node) => {
+  const xml = new XMLSerializer().serializeToString(node);
+  return crlfDeclarations.has(node) ? xml.replace(/^(<\?xml[^>]*\?>)\n/, "$1\r\n") : xml;
+};
+
+// visio/collab/scan.ts
+function* tags(xml) {
+  let i = 0;
+  while (i < xml.length) {
+    const lt = xml.indexOf("<", i);
+    if (lt < 0) return;
+    if (xml.startsWith("<!--", lt)) {
+      const close = xml.indexOf("-->", lt + 4);
+      i = close < 0 ? xml.length : close + 3;
+      continue;
+    }
+    if (xml.startsWith("<![CDATA[", lt)) {
+      const close = xml.indexOf("]]>", lt + 9);
+      i = close < 0 ? xml.length : close + 3;
+      continue;
+    }
+    if (xml[lt + 1] === "?" || xml[lt + 1] === "!") {
+      const close = xml.indexOf(">", lt + 2);
+      i = close < 0 ? xml.length : close + 1;
+      continue;
+    }
+    let j = lt + 1;
+    const closing = xml[j] === "/";
+    if (closing) j++;
+    const nameStart = j;
+    while (j < xml.length && !/[\s/>]/.test(xml[j])) j++;
+    const qualified = xml.slice(nameStart, j);
+    let quote = "";
+    while (j < xml.length) {
+      const ch = xml[j];
+      if (quote) {
+        if (ch === quote) quote = "";
+      } else if (ch === '"' || ch === "'") quote = ch;
+      else if (ch === ">") break;
+      j++;
+    }
+    if (j >= xml.length) return;
+    const colon = qualified.indexOf(":");
+    yield {
+      name: colon < 0 ? qualified : qualified.slice(colon + 1),
+      closing,
+      selfClosing: !closing && xml[j - 1] === "/",
+      start: lt,
+      end: j + 1
+    };
+    i = j + 1;
+  }
+}
+function scanContainer(xml, parent) {
+  const stack = [];
+  let found;
+  const children = [];
+  for (const tag of tags(xml)) {
+    if (tag.closing) {
+      const open = stack.pop();
+      if (!open || open.name !== tag.name) return void 0;
+      if (!found) continue;
+      if (stack.length === found.depth)
+        return {
+          name: parent,
+          start: found.start,
+          openEnd: found.openEnd,
+          closeStart: tag.start,
+          end: tag.end,
+          selfClosing: false,
+          children
+        };
+      if (stack.length === found.depth + 1)
+        children.push({
+          name: tag.name,
+          start: open.start,
+          openEnd: open.openEnd,
+          closeStart: tag.start,
+          end: tag.end,
+          selfClosing: false
+        });
+      continue;
+    }
+    if (!found && tag.name === parent) {
+      if (tag.selfClosing)
+        return {
+          name: parent,
+          start: tag.start,
+          openEnd: tag.end,
+          closeStart: tag.end,
+          end: tag.end,
+          selfClosing: true,
+          children: []
+        };
+      found = { start: tag.start, openEnd: tag.end, depth: stack.length };
+      stack.push({ name: tag.name, start: tag.start, openEnd: tag.end });
+      continue;
+    }
+    if (found && stack.length === found.depth + 1 && tag.selfClosing)
+      children.push({
+        name: tag.name,
+        start: tag.start,
+        openEnd: tag.end,
+        closeStart: tag.end,
+        end: tag.end,
+        selfClosing: true
+      });
+    if (!tag.selfClosing) stack.push({ name: tag.name, start: tag.start, openEnd: tag.end });
+  }
+  return void 0;
+}
+function attrOf(tag, name) {
+  const match = new RegExp(String.raw`\s${name}\s*=\s*(?:"([^"]*)"|'([^']*)')`).exec(tag);
+  return match ? match[1] ?? match[2] : void 0;
+}
+var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
+
+// visio/collab/package.ts
+var dirName = (path) => {
+  const i = path.lastIndexOf("/");
+  return i < 0 ? "" : path.slice(0, i);
+};
+var baseName = (path) => path.slice(path.lastIndexOf("/") + 1);
+var relsPathOf = (part) => {
+  const dir = dirName(part);
+  return `${dir ? `${dir}/` : ""}_rels/${baseName(part)}.rels`;
+};
+function resolveTarget(dir, target) {
+  const parts = target.startsWith("/") ? [] : dir ? dir.split("/") : [];
+  for (const segment of target.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") parts.pop();
+    else parts.push(segment);
+  }
+  return parts.join("/");
+}
+function parseRelationships(xml) {
+  if (!xml) return [];
+  const out = [];
+  for (const match of xml.matchAll(/<(?:\w+:)?Relationship\b[^>]*>/g)) {
+    const text = match[0];
+    const id = attrOf(text, "Id");
+    const type = attrOf(text, "Type");
+    const target = attrOf(text, "Target");
+    if (id === void 0 || type === void 0 || target === void 0) continue;
+    out.push({ id, type, target, external: attrOf(text, "TargetMode") === "External", text });
+  }
+  return out;
+}
+var PAGE_TYPE = "http://schemas.microsoft.com/visio/2010/relationships/page";
+var PAGE_CONTENT_TYPE = "application/vnd.ms-visio.page+xml";
+var REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var isLocalOnlyPart = (path) => /(^|\/)windows\.xml$/i.test(path) || /^docProps\/thumbnail\./i.test(path);
+var CONTENT_TYPES = "[Content_Types].xml";
+function stripPageOverrides(xml) {
+  return xml.replace(
+    /<(?:\w+:)?Override\b[^>]*>/g,
+    (tag) => attrOf(tag, "ContentType") === PAGE_CONTENT_TYPE ? "" : tag
+  );
+}
+function withPageOverrides(xml, pagePaths) {
+  const clean = stripPageOverrides(xml);
+  const add = pagePaths.map((path) => `<Override PartName="/${path}" ContentType="${PAGE_CONTENT_TYPE}"/>`).join("");
+  const close = clean.lastIndexOf("</");
+  return close < 0 ? clean : clean.slice(0, close) + add + clean.slice(close);
+}
+function toBase64(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 32768)
+    out += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(out);
+}
+function fromBase64(text) {
+  const raw = atob(text);
+  const out = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i);
+  return out;
+}
+function fingerprint(bytes) {
+  let hash = 2166136261;
+  for (let i = 0; i < bytes.length; i++) hash = Math.imul(hash ^ bytes[i], 16777619);
+  return `${bytes.length}:${(hash >>> 0).toString(16)}`;
+}
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var canonCache = /* @__PURE__ */ new Map();
+function canon(xml) {
+  const cached = canonCache.get(xml);
+  if (cached !== void 0) return cached;
+  let result = xml;
+  try {
+    result = buildXml(parseXml(xml).documentElement);
+  } catch {
+  }
+  if (canonCache.size > 4e3) canonCache.clear();
+  canonCache.set(xml, result);
+  return result;
+}
+
+// visio/collab/schema.ts
+var SCHEMA_VERSION = 1;
+var META = "visio:meta";
+var PAGES = "visio:pages";
+var BODIES = "visio:bodies";
+var SHAPES = "visio:shapes";
+var CONNECTS = "visio:connects";
+var DEAD = "visio:dead";
+var PARTS = "visio:parts";
+var REL_MARK = "<!--@rel-->";
+var SHAPES_MARK = "<!--@shapes-->";
+var CONNECTS_MARK = "<!--@connects-->";
+function sharedDrawing(doc) {
+  return {
+    meta: doc.getMap(META),
+    pages: doc.getMap(PAGES),
+    bodies: doc.getMap(BODIES),
+    shapes: doc.getMap(SHAPES),
+    connects: doc.getMap(CONNECTS),
+    dead: doc.getMap(DEAD),
+    parts: doc.getMap(PARTS)
+  };
+}
+var sharedTypes = (shared) => [
+  shared.meta,
+  shared.pages,
+  shared.bodies,
+  shared.shapes,
+  shared.connects,
+  shared.dead,
+  shared.parts
+];
+var isSharedDrawingEmpty = (shared) => shared.pages.size === 0 && shared.meta.get("v") === void 0;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function sameRecord(a, b) {
+  if (!isRecord(a) || !isRecord(b)) return a === b;
+  const ka = Object.keys(a).filter((k) => a[k] !== void 0);
+  const kb = Object.keys(b).filter((k) => b[k] !== void 0);
+  return ka.length === kb.length && ka.every((k) => a[k] === b[k]);
+}
+function setIfChanged(map, key, value) {
+  if (sameRecord(map.get(key), value)) return false;
+  map.set(key, value);
+  return true;
+}
+var str = (value) => typeof value === "string" ? value : void 0;
+var num = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+function pageEntry(value) {
+  if (!isRecord(value)) return void 0;
+  const pos = num(value.pos);
+  const id = str(value.id);
+  const xml = str(value.xml);
+  if (pos === void 0 || id === void 0 || xml === void 0) return void 0;
+  const back = str(value.back);
+  return { pos, id, xml, ...back !== void 0 ? { back } : {} };
+}
+function bodyEntry(value) {
+  if (!isRecord(value)) return void 0;
+  const shell = str(value.shell);
+  if (shell === void 0) return void 0;
+  const rels = str(value.rels);
+  return { shell, ...rels !== void 0 ? { rels } : {} };
+}
+function shapeEntry(value) {
+  if (!isRecord(value)) return void 0;
+  const pos = num(value.pos);
+  const xml = str(value.xml);
+  return pos === void 0 || xml === void 0 ? void 0 : { pos, xml };
+}
+function connectEntry(value) {
+  if (!isRecord(value)) return void 0;
+  const out = {};
+  for (const field of ["fk", "fi", "tk", "ti", "fc", "tc", "fp", "tp"]) {
+    const v = str(value[field]);
+    if (v === void 0) return void 0;
+    out[field] = v;
+  }
+  return out;
+}
+var DEFAULT_MAX_PART_BYTES = 48 * 1024 * 1024;
+var SHAPE_ID = /<(?:\w+:)?Shape\s[^>]*?\bID\s*=\s*(["'])(\d+)\1/g;
+function shapeIds(xml) {
+  return [...xml.matchAll(SHAPE_ID)].map((m) => m[2]);
+}
+function splitList(text, name, mark, child) {
+  const box = scanContainer(text, name);
+  if (!box) return { text, items: [] };
+  const items = box.children.filter((c) => c.name === child).map((c) => text.slice(c.start, c.end));
+  if (box.selfClosing) {
+    const tag = text.slice(box.start, box.end);
+    const qualified = /^<([^\s/>]+)/.exec(tag)?.[1] ?? name;
+    const open = tag.replace(/\s*\/>$/, ">");
+    return {
+      text: text.slice(0, box.start) + open + mark + `</${qualified}>` + text.slice(box.end),
+      items
+    };
+  }
+  return { text: text.slice(0, box.openEnd) + mark + text.slice(box.closeStart), items };
+}
+var readZip = (bytes) => JSZip.loadAsync(bytes);
+var zipText = async (zip, path) => zip.file(path)?.async("string");
+async function readLayout(zip) {
+  const root = parseRelationships(await zipText(zip, "_rels/.rels")).find(
+    (r) => r.type.endsWith("/document")
+  );
+  if (!root) return void 0;
+  const documentPath = resolveTarget("", root.target);
+  const rels = parseRelationships(await zipText(zip, relsPathOf(documentPath)));
+  const pages = rels.find((r) => r.type.endsWith("/pages"));
+  return pages ? { documentPath, pagesPath: resolveTarget(dirName(documentPath), pages.target) } : void 0;
+}
+async function readLocalPages(zip, layout, pagesXml) {
+  const box = scanContainer(pagesXml, "Pages");
+  if (!box) return void 0;
+  const rels = new Map(
+    parseRelationships(await zipText(zip, relsPathOf(layout.pagesPath))).map((r) => [r.id, r])
+  );
+  const pages = [];
+  for (const span of box.children) {
+    if (span.name !== "Page") continue;
+    const text = pagesXml.slice(span.start, span.end);
+    const inner = scanContainer(text, "Page");
+    const relSpan = inner?.children.find((c) => c.name === "Rel");
+    if (!inner || !relSpan) return void 0;
+    const relTag = text.slice(relSpan.start, relSpan.openEnd);
+    const rid = /\s(?:\w+:)?id\s*=\s*(["'])([^"']+)\1/.exec(relTag)?.[2];
+    const target = rid ? rels.get(rid)?.target : void 0;
+    const id = attrOf(text.slice(0, inner.openEnd), "ID");
+    if (target === void 0 || id === void 0) return void 0;
+    pages.push({
+      id,
+      text,
+      path: resolveTarget(dirName(layout.pagesPath), target),
+      rel: { start: relSpan.start, end: relSpan.end }
+    });
+  }
+  return { box, pages };
+}
+async function snapshotDrawing(bytes, keys, options = {}) {
+  const zip = await readZip(bytes);
+  const layout = await readLayout(zip);
+  if (!layout) throw new Error("The package has no Visio pages part.");
+  const pagesXml = await zipText(zip, layout.pagesPath) ?? "";
+  const local = await readLocalPages(zip, layout, pagesXml);
+  if (!local) throw new Error("The pages part cannot be split into pages.");
+  const derived = /* @__PURE__ */ new Set([layout.pagesPath, relsPathOf(layout.pagesPath)]);
+  const idToKey = new Map(local.pages.map((p) => [p.id, keys.pageKey(p.id)]));
+  const pages = [];
+  for (const page of local.pages) {
+    const key = idToKey.get(page.id);
+    derived.add(page.path).add(relsPathOf(page.path));
+    const head = page.text.slice(0, scanContainer(page.text, "Page").openEnd);
+    const backId = attrOf(head, "BackPage");
+    const xml = page.text.slice(0, page.rel.start) + REL_MARK + page.text.slice(page.rel.end);
+    const content = await zipText(zip, page.path) ?? "";
+    const rels = await zipText(zip, relsPathOf(page.path));
+    const shapesSplit = splitList(content, "Shapes", SHAPES_MARK, "Shape");
+    const connectsSplit = splitList(shapesSplit.text, "Connects", CONNECTS_MARK, "Connect");
+    const owner = /* @__PURE__ */ new Map();
+    const shapes = [];
+    for (const text of shapesSplit.items) {
+      const ids = shapeIds(text);
+      const id = ids[0];
+      if (id === void 0) continue;
+      const shapeKey = keys.shapeKey(key, id);
+      for (const nested of ids) owner.set(nested, shapeKey);
+      shapes.push({ key: shapeKey, id, xml: text });
+    }
+    const connects = [];
+    for (const text of connectsSplit.items) {
+      const a = (name) => attrOf(text, name) ?? "";
+      const entry = {
+        fk: owner.get(a("FromSheet")) ?? "",
+        fi: a("FromSheet"),
+        tk: owner.get(a("ToSheet")) ?? "",
+        ti: a("ToSheet"),
+        fc: a("FromCell"),
+        tc: a("ToCell"),
+        fp: a("FromPart"),
+        tp: a("ToPart")
+      };
+      connects.push({
+        key: `${key}/${entry.fk}.${entry.fi}.${entry.fc}.${entry.fp}>${entry.tk}.${entry.ti}.${entry.tc}.${entry.tp}`,
+        entry
+      });
+    }
+    keys.pagePaths.set(key, page.path);
+    pages.push({
+      key,
+      id: page.id,
+      ...backId !== void 0 && idToKey.has(backId) ? { back: idToKey.get(backId) } : {},
+      xml,
+      shell: connectsSplit.text,
+      ...rels !== void 0 ? { rels } : {},
+      path: page.path,
+      shapes,
+      connects
+    });
+  }
+  const parts = /* @__PURE__ */ new Map();
+  let total = 0;
+  const limit = options.maxPartBytes ?? DEFAULT_MAX_PART_BYTES;
+  for (const path of Object.keys(zip.files)) {
+    const file = zip.files[path];
+    if (file.dir || derived.has(path) || isLocalOnlyPart(path)) continue;
+    let data = await file.async("uint8array");
+    if (path === CONTENT_TYPES) data = encoder.encode(stripPageOverrides(decoder.decode(data)));
+    total += data.length;
+    if (total > limit) throw new Error("The package parts exceed the shared size limit.");
+    parts.set(path, data);
+  }
+  return {
+    pagesPath: layout.pagesPath,
+    pagesOpen: pagesXml.slice(0, local.box.openEnd),
+    pagesClose: pagesXml.slice(local.box.closeStart),
+    pages,
+    parts
+  };
+}
+
+// visio/collab/order.ts
+function assignPositions(order, current) {
+  const result = /* @__PURE__ */ new Map();
+  const kept = [];
+  let last = -Infinity;
+  for (const key of order) {
+    const pos = current(key);
+    if (pos !== void 0 && pos > last) {
+      kept.push(pos);
+      last = pos;
+    } else kept.push(void 0);
+  }
+  let i = 0;
+  while (i < order.length) {
+    const known = kept[i];
+    if (known !== void 0) {
+      result.set(order[i], known);
+      i++;
+      continue;
+    }
+    let end = i;
+    while (end < order.length && kept[end] === void 0) end++;
+    const lo = i > 0 ? kept[i - 1] : void 0;
+    const hi = end < order.length ? kept[end] : void 0;
+    const count = end - i;
+    for (let j = 0; j < count; j++) {
+      const key = order[i + j];
+      if (lo !== void 0 && hi !== void 0)
+        result.set(key, lo + (hi - lo) * (j + 1) / (count + 1));
+      else if (lo !== void 0) result.set(key, lo + j + 1);
+      else if (hi !== void 0) result.set(key, hi - count + j);
+      else result.set(key, j + 1);
+    }
+    i = end;
+  }
+  return result;
+}
+function byPosition(items) {
+  return items.sort((a, b) => a.pos - b.pos || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+}
+
+// visio/collab/write.ts
+var pageId = (key) => `p:${key}`;
+var bodyId = (key) => `b:${key}`;
+var shapeId = (page, key) => `s:${page}/${key}`;
+var connectId = (key) => `c:${key}`;
+var pageContent = (e) => JSON.stringify([e.id, e.back ?? null, canon(e.xml)]);
+var bodyContent = (e) => JSON.stringify([canon(e.shell), e.rels ?? null]);
+function writeSharedDrawing(shared, snapshot, keys) {
+  let writes = 0;
+  const set = (map, key, value) => {
+    if (setIfChanged(map, key, value)) writes++;
+  };
+  set(shared.meta, "v", SCHEMA_VERSION);
+  set(shared.meta, "pagesPath", snapshot.pagesPath);
+  set(shared.meta, "pagesOpen", snapshot.pagesOpen);
+  set(shared.meta, "pagesClose", snapshot.pagesClose);
+  const now = /* @__PURE__ */ new Map();
+  const changed = (id, content, room) => {
+    const base = keys.known.get(id);
+    return base === void 0 ? room !== content : base !== content;
+  };
+  const pagePos = assignPositions(
+    snapshot.pages.map((p) => p.key),
+    (key) => pageEntry(shared.pages.get(key))?.pos
+  );
+  for (const page of snapshot.pages) {
+    const room = pageEntry(shared.pages.get(page.key));
+    const content = pageContent(page);
+    now.set(pageId(page.key), content);
+    const own = changed(pageId(page.key), content, room && pageContent(room));
+    const source = own || !room ? page : room;
+    set(shared.pages, page.key, {
+      pos: pagePos.get(page.key),
+      id: source.id,
+      ...source.back !== void 0 ? { back: source.back } : {},
+      xml: source.xml
+    });
+    const roomBody = bodyEntry(shared.bodies.get(page.key));
+    const bodyText = bodyContent(page);
+    now.set(bodyId(page.key), bodyText);
+    const ownBody = changed(bodyId(page.key), bodyText, roomBody && bodyContent(roomBody));
+    const body = ownBody || !roomBody ? page : roomBody;
+    set(shared.bodies, page.key, {
+      shell: body.shell,
+      ...body.rels !== void 0 ? { rels: body.rels } : {}
+    });
+    const shapePos = assignPositions(
+      page.shapes.map((s) => s.key),
+      (key) => shapeEntry(shared.shapes.get(`${page.key}/${key}`))?.pos
+    );
+    for (const shape of page.shapes) {
+      const id = shapeId(page.key, shape.key);
+      const roomShape = shapeEntry(shared.shapes.get(`${page.key}/${shape.key}`));
+      const text = canon(shape.xml);
+      now.set(id, text);
+      const xml = changed(id, text, roomShape && canon(roomShape.xml)) || !roomShape ? shape.xml : roomShape.xml;
+      set(shared.shapes, `${page.key}/${shape.key}`, { pos: shapePos.get(shape.key), xml });
+    }
+    for (const connect of page.connects) {
+      now.set(connectId(connect.key), "");
+      if (!keys.known.has(connectId(connect.key)) || !shared.connects.has(connect.key))
+        set(shared.connects, connect.key, connect.entry);
+    }
+  }
+  for (const id of keys.known.keys()) {
+    if (now.has(id)) continue;
+    const name = id.slice(2);
+    if (id.startsWith("p:")) {
+      shared.dead.set(name, true);
+      for (const map of [shared.pages, shared.bodies]) map.delete(name);
+      for (const map of [shared.shapes, shared.connects])
+        for (const key of [...map.keys()]) if (key.startsWith(`${name}/`)) map.delete(key);
+      keys.forgetPage(name);
+      writes++;
+    } else if (id.startsWith("s:")) {
+      const slash = name.indexOf("/");
+      const page = name.slice(0, slash);
+      if (!now.has(pageId(page))) continue;
+      shared.dead.set(name, true);
+      shared.shapes.delete(name);
+      keys.forgetShape(page, name.slice(slash + 1));
+      writes++;
+    } else if (id.startsWith("c:") && shared.connects.has(name)) {
+      shared.connects.delete(name);
+      writes++;
+    }
+  }
+  keys.known = now;
+  for (const [path, data] of snapshot.parts) {
+    const print = fingerprint(data);
+    if (keys.partPrints.get(path) === print) continue;
+    set(shared.parts, path, toBase64(data));
+    keys.partPrints.set(path, print);
+  }
+  for (const path of [...keys.partPrints.keys()])
+    if (!snapshot.parts.has(path)) {
+      shared.parts.delete(path);
+      keys.partPrints.delete(path);
+      writes++;
+    }
+  return writes;
+}
+
+// visio/collab/compose.ts
+var DEFAULT_CONTENT_TYPES = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"></Types>';
+function connectXml(item) {
+  const attrs = [
+    ["FromSheet", item.from],
+    ["FromCell", item.entry.fc],
+    ["FromPart", item.entry.fp],
+    ["ToSheet", item.to],
+    ["ToCell", item.entry.tc],
+    ["ToPart", item.entry.tp]
+  ];
+  return `<Connect ${attrs.filter(([, v]) => v !== "").map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ")}/>`;
+}
+function pagePartXml(page) {
+  let shell = page.body.shell;
+  const root = scanContainer(shell, "PageContents");
+  if (page.shapes.length && !shell.includes(SHAPES_MARK) && root && !root.selfClosing)
+    shell = shell.slice(0, root.openEnd) + `<Shapes>${SHAPES_MARK}</Shapes>` + shell.slice(root.openEnd);
+  const root2 = scanContainer(shell, "PageContents");
+  if (page.connects.length && !shell.includes(CONNECTS_MARK) && root2 && !root2.selfClosing)
+    shell = shell.slice(0, root2.closeStart) + `<Connects>${CONNECTS_MARK}</Connects>` + shell.slice(root2.closeStart);
+  return shell.replace(SHAPES_MARK, () => page.shapes.map((s) => s.xml).join("")).replace(CONNECTS_MARK, () => page.connects.map(connectXml).join(""));
+}
+function relTarget(pagesDir, path) {
+  return pagesDir && path.startsWith(`${pagesDir}/`) ? path.slice(pagesDir.length + 1) : `/${path}`;
+}
+async function composeDrawing(drawing, local, keys, options = {}) {
+  const localZip = local ? await readZip(local) : void 0;
+  const files = /* @__PURE__ */ new Map();
+  const prints = /* @__PURE__ */ new Map();
+  let total = 0;
+  const limit = options.maxPartBytes ?? 48 * 1024 * 1024;
+  for (const [path, b64] of drawing.parts) {
+    const data = fromBase64(b64);
+    total += data.length;
+    if (total > limit) throw new Error("The shared parts exceed the size limit.");
+    files.set(path, data);
+    prints.set(path, fingerprint(data));
+  }
+  if (localZip)
+    for (const path of Object.keys(localZip.files)) {
+      const file = localZip.files[path];
+      if (!file.dir && isLocalOnlyPart(path) && !files.has(path))
+        files.set(path, await file.async("uint8array"));
+    }
+  let contentTypes = files.get(CONTENT_TYPES) !== void 0 ? decoder.decode(files.get(CONTENT_TYPES)) : (localZip && await zipText(localZip, CONTENT_TYPES)) ?? DEFAULT_CONTENT_TYPES;
+  for (const [path, data] of [...files]) {
+    if (!path.endsWith(".rels") || typeof data === "string") continue;
+    const source = path.replace(/(^|\/)_rels\/([^/]+)\.rels$/, "$1$2");
+    const base = dirName(source);
+    const text = decoder.decode(data);
+    const next = text.replace(/<(?:\w+:)?Relationship\b[^>]*>/g, (tag) => {
+      const target = attrOf(tag, "Target");
+      if (target === void 0 || attrOf(tag, "TargetMode") === "External") return tag;
+      const resolved = resolveTarget(base, target);
+      if (!isLocalOnlyPart(resolved) || files.has(resolved)) return tag;
+      contentTypes = contentTypes.replace(
+        /<(?:\w+:)?Override\b[^>]*>/g,
+        (o) => attrOf(o, "PartName") === `/${resolved}` ? "" : o
+      );
+      return "";
+    });
+    if (next !== text) files.set(path, encoder.encode(next));
+  }
+  const pagesDir = dirName(drawing.pagesPath);
+  const taken = /* @__PURE__ */ new Set([
+    ...files.keys(),
+    drawing.pagesPath,
+    relsPathOf(drawing.pagesPath)
+  ]);
+  const paths = /* @__PURE__ */ new Map();
+  for (const page of drawing.pages) {
+    const known = keys.pagePaths.get(page.key);
+    if (known && !taken.has(known) && localZip?.file(known)) {
+      paths.set(page.key, known);
+      taken.add(known);
+    }
+  }
+  let counter = 0;
+  for (const page of drawing.pages) {
+    if (paths.has(page.key)) continue;
+    let path;
+    do
+      path = `${pagesDir ? `${pagesDir}/` : ""}page${++counter}.xml`;
+    while (taken.has(path) || localZip?.file(path));
+    paths.set(page.key, path);
+    taken.add(path);
+  }
+  const others = parseRelationships(
+    localZip ? await zipText(localZip, relsPathOf(drawing.pagesPath)) : void 0
+  ).filter((r) => r.type !== PAGE_TYPE);
+  const usedIds = new Set(others.map((r) => r.id));
+  let nextRel = 0;
+  const pageRels = [];
+  const pageXml = [];
+  for (const page of drawing.pages) {
+    const path = paths.get(page.key);
+    let id;
+    do
+      id = `rId${++nextRel}`;
+    while (usedIds.has(id));
+    usedIds.add(id);
+    pageRels.push(
+      `<Relationship Id="${id}" Type="${PAGE_TYPE}" Target="${escapeAttr(relTarget(pagesDir, path))}"/>`
+    );
+    const rel = `<Rel xmlns:r="${REL_NS}" r:id="${id}"/>`;
+    pageXml.push(
+      page.xml.includes(REL_MARK) ? page.xml.replace(REL_MARK, () => rel) : page.xml.slice(0, page.xml.lastIndexOf("</")) + rel + page.xml.slice(page.xml.lastIndexOf("</"))
+    );
+    files.set(path, encoder.encode(pagePartXml(page)));
+    if (page.body.rels !== void 0) files.set(relsPathOf(path), encoder.encode(page.body.rels));
+  }
+  files.set(
+    drawing.pagesPath,
+    encoder.encode(drawing.pagesOpen + pageXml.join("") + drawing.pagesClose)
+  );
+  files.set(
+    relsPathOf(drawing.pagesPath),
+    encoder.encode(
+      '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' + others.map((r) => r.text).join("") + pageRels.join("") + "</Relationships>"
+    )
+  );
+  files.set(CONTENT_TYPES, encoder.encode(withPageOverrides(contentTypes, [...paths.values()])));
+  const zip = new JSZip();
+  const names = [...files.keys()].sort(
+    (a, b) => a === CONTENT_TYPES ? -1 : b === CONTENT_TYPES ? 1 : 0
+  );
+  for (const name of names) zip.file(name, files.get(name), { createFolders: false });
+  const bytes = await zip.generateAsync({ type: "uint8array", compression: "STORE" });
+  const commit = () => {
+    const pageIds = /* @__PURE__ */ new Map();
+    const shapeIds2 = /* @__PURE__ */ new Map();
+    const known = /* @__PURE__ */ new Map();
+    keys.pagePaths.clear();
+    for (const page of drawing.pages) {
+      pageIds.set(page.id, page.key);
+      keys.pagePaths.set(page.key, paths.get(page.key));
+      known.set(pageId(page.key), pageContent(page));
+      known.set(bodyId(page.key), bodyContent(page.body));
+      shapeIds2.set(page.key, new Map(page.shapes.map((s) => [s.id, s.key])));
+      for (const shape of page.shapes) known.set(shapeId(page.key, shape.key), canon(shape.xml));
+      for (const connect of page.connects) known.set(connectId(connect.key), "");
+    }
+    keys.reset(pageIds, shapeIds2);
+    keys.known = known;
+    keys.partPrints.clear();
+    for (const [path, print] of prints) keys.partPrints.set(path, print);
+  };
+  return { bytes, commit };
+}
+
+// visio/collab/keys.ts
+var DrawingKeys = class {
+  constructor(tag) {
+    this.tag = tag;
+  }
+  tag;
+  #counter = 0;
+  /** Seeding derives keys from ids; otherwise they are minted. */
+  seeding = false;
+  #pages = /* @__PURE__ */ new Map();
+  #shapes = /* @__PURE__ */ new Map();
+  /** Content of each entry this peer last wrote or applied, to tell a local edit or deletion from a change it has not applied yet. */
+  known = /* @__PURE__ */ new Map();
+  /** Fingerprints of the parts this peer last wrote or applied. */
+  partPrints = /* @__PURE__ */ new Map();
+  /** The part path of each page key in the local package. */
+  pagePaths = /* @__PURE__ */ new Map();
+  mint() {
+    return `${this.tag}.${(++this.#counter).toString(36)}`;
+  }
+  pageKey(id) {
+    let key = this.#pages.get(id);
+    if (key === void 0) {
+      key = this.seeding ? `s${id}` : this.mint();
+      this.#pages.set(id, key);
+    }
+    return key;
+  }
+  shapeKey(pageKey, id) {
+    let map = this.#shapes.get(pageKey);
+    if (!map) this.#shapes.set(pageKey, map = /* @__PURE__ */ new Map());
+    let key = map.get(id);
+    if (key === void 0) {
+      key = this.seeding ? `s${id}` : this.mint();
+      map.set(id, key);
+    }
+    return key;
+  }
+  findPage(id) {
+    return this.#pages.get(id);
+  }
+  forgetPage(key) {
+    for (const [id, k] of this.#pages) if (k === key) this.#pages.delete(id);
+    this.#shapes.delete(key);
+  }
+  forgetShape(pageKey, key) {
+    const map = this.#shapes.get(pageKey);
+    if (map) {
+      for (const [id, k] of map) if (k === key) map.delete(id);
+    }
+  }
+  /** Replaces the id-to-key tables with those of a freshly composed package. */
+  reset(pages, shapes) {
+    this.#pages.clear();
+    this.#shapes.clear();
+    for (const [id, key] of pages) this.#pages.set(id, key);
+    for (const [page, map] of shapes) this.#shapes.set(page, new Map(map));
+  }
+};
+
+// visio/collab/read.ts
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var numeric = (id) => /^\d+$/.test(id) ? Number(id) : 0;
+function setAttr(open, name, value) {
+  return open.replace(
+    new RegExp(String.raw`(\s${name}\s*=\s*)(?:"[^"]*"|'[^']*')`),
+    (_m, head) => `${head}"${value}"`
+  );
+}
+function renumberShape(xml, remap) {
+  if (!remap.size) return xml;
+  return xml.replace(
+    /<(?:\w+:)?Shape\s[^>]*>/g,
+    (tag) => tag.replace(/(\bID\s*=\s*)(["'])(\d+)\2/, (m, head, q, id) => {
+      const next = remap.get(id);
+      return next === void 0 ? m : `${head}${q}${next}${q}`;
+    })
+  ).replace(/Sheet\.(\d+)(?!\d)/g, (m, id) => {
+    const next = remap.get(id);
+    return next === void 0 ? m : `Sheet.${next}`;
+  });
+}
+function readSharedDrawing(shared) {
+  if (isSharedDrawingEmpty(shared)) return void 0;
+  const pagesPath = str(shared.meta.get("pagesPath"));
+  const pagesOpen = str(shared.meta.get("pagesOpen"));
+  const pagesClose = str(shared.meta.get("pagesClose"));
+  if (pagesPath === void 0 || pagesOpen === void 0 || pagesClose === void 0)
+    return void 0;
+  const alive = [...shared.pages].filter(([key]) => !shared.dead.has(key)).flatMap(([key, value]) => {
+    const entry = pageEntry(value);
+    const body = bodyEntry(shared.bodies.get(key));
+    return entry && body ? [{ key, pos: entry.pos, entry, body }] : [];
+  });
+  const pageIds = /* @__PURE__ */ new Map();
+  const taken = /* @__PURE__ */ new Set();
+  let maxPage = Math.max(0, ...alive.map((p) => numeric(p.entry.id)));
+  for (const page of [...alive].sort((a, b) => compare(a.key, b.key))) {
+    let id = page.entry.id;
+    if (taken.has(id)) id = String(++maxPage);
+    taken.add(id);
+    pageIds.set(page.key, id);
+  }
+  const shapesByPage = /* @__PURE__ */ new Map();
+  for (const [full, value] of shared.shapes) {
+    const slash = full.indexOf("/");
+    if (slash < 0 || shared.dead.has(full)) continue;
+    const entry = shapeEntry(value);
+    if (!entry) continue;
+    const page = full.slice(0, slash);
+    const list = shapesByPage.get(page) ?? [];
+    list.push({ key: full.slice(slash + 1), pos: entry.pos, xml: entry.xml });
+    shapesByPage.set(page, list);
+  }
+  const connectsByPage = /* @__PURE__ */ new Map();
+  for (const [full, value] of shared.connects) {
+    const entry = connectEntry(value);
+    const slash = full.indexOf("/");
+    if (!entry || slash < 0) continue;
+    const list = connectsByPage.get(full.slice(0, slash)) ?? [];
+    list.push({ key: full, entry });
+    connectsByPage.set(full.slice(0, slash), list);
+  }
+  const pages = [];
+  for (const page of byPosition(alive)) {
+    const finalId = pageIds.get(page.key);
+    const shapes = resolveShapes(shapesByPage.get(page.key) ?? []);
+    const byKey = new Map(shapes.map((s) => [s.key, s]));
+    const connects = [];
+    for (const item of (connectsByPage.get(page.key) ?? []).sort((a, b) => compare(a.key, b.key))) {
+      const { entry } = item;
+      const from = entry.fk ? byKey.get(entry.fk) : void 0;
+      const to = entry.tk ? byKey.get(entry.tk) : void 0;
+      if (entry.fk && !from || entry.tk && !to) continue;
+      connects.push({
+        key: item.key,
+        entry,
+        from: from?.remap.get(entry.fi) ?? entry.fi,
+        to: to?.remap.get(entry.ti) ?? entry.ti
+      });
+    }
+    let xml = page.entry.xml;
+    const open = /^<[^>]*>/.exec(xml)?.[0];
+    if (open) {
+      let next = setAttr(open, "ID", finalId);
+      const back = page.entry.back !== void 0 ? pageIds.get(page.entry.back) : void 0;
+      if (back !== void 0) next = setAttr(next, "BackPage", back);
+      xml = next + xml.slice(open.length);
+    }
+    pages.push({
+      key: page.key,
+      id: finalId,
+      ...page.entry.back !== void 0 ? { back: page.entry.back } : {},
+      xml,
+      body: page.body,
+      shapes,
+      connects
+    });
+  }
+  const parts = /* @__PURE__ */ new Map();
+  for (const [path, value] of shared.parts) if (typeof value === "string") parts.set(path, value);
+  return { pagesPath, pagesOpen, pagesClose, pages, parts };
+}
+function resolveShapes(entries) {
+  const parsed = entries.map((entry) => ({ ...entry, ids: shapeIds(entry.xml) }));
+  let max = Math.max(0, ...parsed.flatMap((p) => p.ids.map(numeric)));
+  const used = /* @__PURE__ */ new Set();
+  const done = /* @__PURE__ */ new Map();
+  for (const item of [...parsed].sort((a, b) => compare(a.key, b.key))) {
+    const remap = /* @__PURE__ */ new Map();
+    for (const id of item.ids) {
+      if (used.has(id) || remap.has(id)) remap.set(id, String(++max));
+    }
+    const ids = item.ids.map((id) => remap.get(id) ?? id);
+    for (const id of ids) used.add(id);
+    done.set(item.key, {
+      key: item.key,
+      id: ids[0] ?? "",
+      xml: renumberShape(item.xml, remap),
+      remap,
+      ids
+    });
+  }
+  return byPosition(parsed).map((item) => done.get(item.key));
+}
+
+// visio/collab/bind.ts
+var VISIO_EDIT_ORIGIN = /* @__PURE__ */ Symbol("ooxml-core:visio:edit");
+var VISIO_SYNC_ORIGIN = /* @__PURE__ */ Symbol("ooxml-core:visio:sync");
+function bindDrawingSession(host, editor, options = {}) {
+  const { doc } = host;
+  const shared = sharedDrawing(doc);
+  const types = sharedTypes(shared);
+  const keys = new DrawingKeys(options.keyTag ?? doc.clientID.toString(36));
+  const undoManager = new Y.UndoManager(types, {
+    trackedOrigins: /* @__PURE__ */ new Set([VISIO_EDIT_ORIGIN]),
+    captureTimeout: 0
+  });
+  const historyListeners = /* @__PURE__ */ new Set();
+  const historyChanged = () => {
+    for (const listener of [...historyListeners]) listener();
+  };
+  for (const event of ["stack-item-added", "stack-item-popped", "stack-cleared"])
+    undoManager.on(event, historyChanged);
+  let disposed = false;
+  let settled = false;
+  let localDirty = false;
+  let remoteDirty = false;
+  let running;
+  const report = (error) => options.onError?.(error);
+  const publish = async () => {
+    const bytes = editor.exportBytes();
+    if (!bytes) return;
+    keys.seeding = keys.known.size === 0 && isSharedDrawingEmpty(shared);
+    const snapshot = await snapshotDrawing(bytes, keys);
+    if (disposed) return;
+    const seed = isSharedDrawingEmpty(shared);
+    doc.transact(
+      () => writeSharedDrawing(shared, snapshot, keys),
+      seed ? VISIO_SYNC_ORIGIN : VISIO_EDIT_ORIGIN
+    );
+    undoManager.stopCapturing();
+  };
+  const rebuild = async () => {
+    const resolved = readSharedDrawing(shared);
+    if (!resolved) return;
+    const version = editor.version();
+    const composed = await composeDrawing(resolved, editor.exportBytes(), keys);
+    if (disposed) return;
+    if (editor.busy() || editor.version() !== version) {
+      remoteDirty = true;
+      return;
+    }
+    try {
+      await editor.applyRemote(composed.bytes);
+    } catch (error) {
+      if (editor.busy()) remoteDirty = true;
+      else report(error);
+      return;
+    }
+    composed.commit();
+  };
+  const blocked = () => disposed || !settled || editor.busy();
+  const pending = () => !blocked() && (localDirty && host.canWrite() || remoteDirty && !localDirty);
+  const loop = async () => {
+    while (pending()) {
+      try {
+        if (localDirty) {
+          localDirty = false;
+          await publish();
+        } else if (remoteDirty) {
+          remoteDirty = false;
+          await rebuild();
+        }
+      } catch (error) {
+        report(error);
+      }
+    }
+  };
+  const pump = () => {
+    if (running || !pending()) return;
+    running = loop().finally(() => {
+      running = void 0;
+      pump();
+    });
+  };
+  const settle = () => {
+    if (disposed || settled) return;
+    if (isSharedDrawingEmpty(shared)) {
+      if (!host.canWrite()) return;
+      settled = true;
+      if (options.seed !== false) {
+        localDirty = editor.exportBytes() !== void 0 || editor.busy();
+      }
+    } else {
+      settled = true;
+      localDirty = false;
+      remoteDirty = true;
+    }
+    pump();
+  };
+  const afterTransaction = (transaction) => {
+    if (disposed) return;
+    const origin = transaction.origin;
+    if (origin === VISIO_EDIT_ORIGIN || origin === VISIO_SYNC_ORIGIN) return;
+    const changed = transaction.changed;
+    if (!types.some((type) => changed.has(type))) return;
+    if (!settled) {
+      if (!isSharedDrawingEmpty(shared)) settle();
+      return;
+    }
+    remoteDirty = true;
+    pump();
+  };
+  doc.on("afterTransaction", afterTransaction);
+  const stops = [
+    editor.onLocalChange(() => {
+      if (disposed) return;
+      localDirty = true;
+      pump();
+    }),
+    editor.onIdle(pump),
+    host.on("ready", settle),
+    host.on("synced", () => {
+      settle();
+      pump();
+    })
+  ];
+  if (host.synced || host.canWrite()) settle();
+  const idle = async () => {
+    while (running) await running;
+  };
+  const replay = async (kind) => {
+    await idle();
+    const stack = kind === "undo" ? undoManager.undoStack : undoManager.redoStack;
+    if (disposed || !stack.length) return false;
+    if (kind === "undo") undoManager.undo();
+    else undoManager.redo();
+    await idle();
+    return true;
+  };
+  return {
+    undo: () => replay("undo"),
+    redo: () => replay("redo"),
+    canUndo: () => undoManager.undoStack.length > 0,
+    canRedo: () => undoManager.redoStack.length > 0,
+    onHistoryChange: (listener) => {
+      historyListeners.add(listener);
+      return () => historyListeners.delete(listener);
+    },
+    idle,
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      doc.off("afterTransaction", afterTransaction);
+      for (const stop of stops) stop();
+      undoManager.destroy();
+      historyListeners.clear();
+    }
+  };
+}
+
+export { BODIES, CONNECTS, DEAD, DrawingKeys, META, PAGES, PARTS, SCHEMA_VERSION, SHAPES, VISIO_EDIT_ORIGIN, VISIO_SYNC_ORIGIN, bindDrawingSession, composeDrawing, isSharedDrawingEmpty, readSharedDrawing, sharedDrawing, snapshotDrawing, writeSharedDrawing };