ooxml-core 1.22.0 → 1.23.0

package/dist/visio/collab/index.cjs

@@ -28,6 +28,143 @@ var Y__namespace = /*#__PURE__*/_interopNamespace(Y);
 var JSZip__default = /*#__PURE__*/_interopDefault(JSZip);
 
 // visio/collab/bind.ts
+
+// digest/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var IV = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+var W = new Uint32Array(64);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function compress(h, view, offset) {
+  for (let i = 0; i < 16; i++) W[i] = view.getUint32(offset + i * 4);
+  for (let i = 16; i < 64; i++) {
+    const a2 = W[i - 15];
+    const b2 = W[i - 2];
+    const s0 = rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3;
+    const s1 = rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10;
+    W[i] = W[i - 16] + s0 + W[i - 7] + s1 >>> 0;
+  }
+  let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], k = h[7];
+  for (let i = 0; i < 64; i++) {
+    const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+    const ch = e & f ^ ~e & g;
+    const t1 = k + S1 + ch + K[i] + W[i] >>> 0;
+    const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+    const maj = a & b ^ a & c ^ b & c;
+    const t2 = S0 + maj >>> 0;
+    k = g;
+    g = f;
+    f = e;
+    e = d + t1 >>> 0;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2 >>> 0;
+  }
+  h[0] = h[0] + a >>> 0;
+  h[1] = h[1] + b >>> 0;
+  h[2] = h[2] + c >>> 0;
+  h[3] = h[3] + d >>> 0;
+  h[4] = h[4] + e >>> 0;
+  h[5] = h[5] + f >>> 0;
+  h[6] = h[6] + g >>> 0;
+  h[7] = h[7] + k >>> 0;
+}
+function pad64(data) {
+  const padded = new Uint8Array(Math.ceil((data.length + 9) / 64) * 64);
+  padded.set(data);
+  padded[data.length] = 128;
+  const bits = data.length * 8;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
+  view.setUint32(padded.length - 4, bits >>> 0);
+  return view;
+}
+function wordsOut(h) {
+  const out = new Uint8Array(h.length * 4);
+  const view = new DataView(out.buffer);
+  for (let i = 0; i < h.length; i++) view.setUint32(i * 4, h[i]);
+  return out;
+}
+function sha256(data) {
+  const h = new Uint32Array(IV);
+  const view = pad64(data);
+  for (let offset = 0; offset < view.byteLength; offset += 64) compress(h, view, offset);
+  return wordsOut(h);
+}
 var DEFAULT_XML_LIMITS = {
   maxDepth: 512,
   maxNodes: 5e6
@@ -278,11 +415,51 @@ function stripPageOverrides(xml) {
     (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);
+var withPageOverrides = (xml, pagePaths) => withOverrides(stripPageOverrides(xml), PAGE_CONTENT_TYPE, pagePaths);
+var MASTER_TYPE = "http://schemas.microsoft.com/visio/2010/relationships/master";
+var MASTER_CONTENT_TYPE = "application/vnd.ms-visio.master+xml";
+function withOverrides(xml, contentType, paths) {
+  const add = paths.map((path) => `<Override PartName="/${path}" ContentType="${contentType}"/>`).join("");
+  const close = xml.lastIndexOf("</");
+  return close < 0 ? xml : xml.slice(0, close) + add + xml.slice(close);
+}
+function stripOverrides(xml, types, parts = /* @__PURE__ */ new Set()) {
+  return xml.replace(/<(?:\w+:)?Override\b[^>]*>/g, (tag) => {
+    const type = attrOf(tag, "ContentType");
+    const name = attrOf(tag, "PartName");
+    return type !== void 0 && types.includes(type) || name !== void 0 && parts.has(name.replace(/^\//, "")) ? "" : tag;
+  });
+}
+function declaredType(xml, path) {
+  for (const tag of xml.matchAll(/<(?:\w+:)?Override\b[^>]*>/g)) {
+    const name = attrOf(tag[0], "PartName");
+    const type = attrOf(tag[0], "ContentType");
+    if (name === `/${path}` && type !== void 0) return { type, byDefault: false };
+  }
+  const ext = /\.([^./]+)$/.exec(path)?.[1]?.toLowerCase();
+  if (ext === void 0) return void 0;
+  for (const tag of xml.matchAll(/<(?:\w+:)?Default\b[^>]*>/g)) {
+    const e = attrOf(tag[0], "Extension");
+    const type = attrOf(tag[0], "ContentType");
+    if (e?.toLowerCase() === ext && type !== void 0) return { type, byDefault: true };
+  }
+  return void 0;
+}
+function ensureType(xml, path, declared) {
+  if (declaredType(xml, path)) return xml;
+  const close = xml.lastIndexOf("</");
+  if (close < 0) return xml;
+  const ext = /\.([^./]+)$/.exec(path)?.[1];
+  const tag = declared.byDefault && ext ? `<Default Extension="${ext}" ContentType="${declared.type}"/>` : `<Override PartName="/${path}" ContentType="${declared.type}"/>`;
+  return xml.slice(0, close) + tag + xml.slice(close);
+}
+var isMediaPart = (path) => /(^|\/)media\/[^/]+$/i.test(path);
+function relativeTarget(dir, path) {
+  const from = dir ? dir.split("/") : [];
+  const to = path.split("/");
+  let i = 0;
+  while (i < from.length && i < to.length - 1 && from[i] === to[i]) i++;
+  return [...from.slice(i).map(() => ".."), ...to.slice(i)].join("/");
 }
 function toBase64(bytes) {
   let out = "";
@@ -316,15 +493,154 @@ function canon(xml) {
   canonCache.set(xml, result);
   return result;
 }
+function contentHash(bytes) {
+  let out = "";
+  for (const byte of sha256(bytes)) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+
+// visio/collab/pieces.ts
+var seg = (value) => value.replace(/[%/]/g, (c) => c === "%" ? "%25" : "%2F");
+var tagName = (open) => /^<([^\s/>]+)/.exec(open)?.[1] ?? "Shape";
+var openTagOf = (text, span) => {
+  const tag = text.slice(span.start, span.openEnd);
+  return span.selfClosing ? tag.replace(/\s*\/>$/, ">") : tag;
+};
+var closeTagOf = (open) => `</${tagName(open)}>`;
+function splitShape(xml) {
+  const box = scanContainer(xml, "Shape");
+  if (!box) return void 0;
+  const used = /* @__PURE__ */ new Set();
+  const unique = (path) => {
+    let out = path;
+    for (let n = 2; used.has(out); n++) out = `${path}~${n}`;
+    used.add(out);
+    return out;
+  };
+  const pieces = [];
+  const nested = [];
+  const others = /* @__PURE__ */ new Map();
+  const other = (parent, name, text) => {
+    const k = others.get(parent + name) ?? 0;
+    others.set(parent + name, k + 1);
+    pieces.push({
+      path: unique(`${parent ? `${parent}/` : ""}x/${name}#${k}`),
+      parent,
+      kind: "leaf",
+      text
+    });
+  };
+  const cell = (parent, text) => {
+    const n = attrOf(text.slice(0, text.search(/>/) + 1), "N");
+    if (n === void 0) return other(parent, "Cell", text);
+    pieces.push({
+      path: unique(`${parent ? `${parent}/` : ""}c/${seg(n)}`),
+      parent,
+      kind: "leaf",
+      text
+    });
+  };
+  for (const child of box.children) {
+    const text = xml.slice(child.start, child.end);
+    if (child.name === "Cell") cell("", text);
+    else if (child.name === "Shapes") {
+      const list = scanContainer(text, "Shapes");
+      for (const s of list?.children ?? [])
+        if (s.name === "Shape") nested.push(text.slice(s.start, s.end));
+    } else if (child.name === "Section") {
+      const head = openTagOf(xml, child);
+      const n = attrOf(head, "N");
+      const ix = attrOf(head, "IX");
+      if (n === void 0 && ix === void 0) {
+        other("", "Section", text);
+        continue;
+      }
+      const sec = unique(`s/${seg(n ?? "")}${ix !== void 0 ? `:${seg(ix)}` : ""}`);
+      pieces.push({ path: sec, parent: "", kind: "open", text: head });
+      const inner = scanContainer(text, "Section");
+      let rowIndex = 0;
+      for (const part of inner?.children ?? []) {
+        const sub = text.slice(part.start, part.end);
+        if (part.name === "Cell") cell(sec, sub);
+        else if (part.name === "Row") {
+          const rowHead = openTagOf(text, part);
+          const id = attrOf(rowHead, "IX") ?? attrOf(rowHead, "N") ?? `#${rowIndex}`;
+          rowIndex++;
+          const row = unique(`${sec}/r/${seg(id)}`);
+          pieces.push({ path: row, parent: sec, kind: "open", text: rowHead });
+          for (const rc of scanContainer(sub, "Row")?.children ?? [])
+            if (rc.name === "Cell") cell(row, sub.slice(rc.start, rc.end));
+            else other(row, rc.name, sub.slice(rc.start, rc.end));
+        } else other(sec, part.name, sub);
+      }
+    } else other("", child.name, text);
+  }
+  return { open: openTagOf(xml, box), pieces, nested };
+}
+function buildShape(open, entries, tail) {
+  const byParent = /* @__PURE__ */ new Map();
+  for (const [path, entry] of entries) {
+    const parent = parentOf(path);
+    const list = byParent.get(parent) ?? [];
+    list.push({ path, entry });
+    byParent.set(parent, list);
+  }
+  const render = (parent) => (byParent.get(parent) ?? []).sort((a, b) => a.entry.pos - b.entry.pos || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0)).map(
+    ({ path, entry }) => entry.open !== void 0 ? entry.open + render(path) + closeTagOf(entry.open) : entry.xml ?? ""
+  ).join("");
+  return open + render("") + tail + closeTagOf(open);
+}
+function parentOf(path) {
+  const parts = path.split("/");
+  return parts.length <= 2 ? "" : parts.slice(0, -2).join("/");
+}
+var SIMPLE = /^<([^\s/>]+)((?:\s+[^\s=/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(?:\/>|>([^<]*)<\/\1>)$/;
+var ATTR = /\s([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+function pieceContent(kind, text) {
+  const simple = SIMPLE.exec(kind === "open" ? `${text}</${tagName(text)}>` : text);
+  if (!simple) return kind === "open" ? canon(`${text}</${tagName(text)}>`) : canon(text);
+  const attrs = [...(simple[2] ?? "").matchAll(ATTR)].map((m) => [m[1], m[2] ?? m[3] ?? ""]).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  return JSON.stringify([simple[1], attrs, simple[3] ?? ""]);
+}
+
+// visio/collab/baseline.ts
+var masterScope = (key) => `m~${key}`;
+var pageId = (key) => `p:${key}`;
+var bodyId = (key) => `b:${key}`;
+var shapeId = (page, key) => `s:${page}/${key}`;
+var cellId = (page, shape, path) => `f:${page}/${shape}/${path}`;
+var connectId = (key) => `c:${key}`;
+var masterId = (key) => `m:${key}`;
+var mediaId = (key) => `i:${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]);
+var shellContent = (e) => JSON.stringify([e.parent ?? null, pieceContent("open", e.open)]);
+var entryContent = (e) => e.xml !== void 0 ? pieceContent("leaf", e.xml) : pieceContent("open", e.open ?? "");
+var masterContent = (e) => JSON.stringify([e.id, canon(e.xml), e.rels ?? null, e.print]);
 
 // visio/collab/schema.ts
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 3;
+var SchemaVersionError = class extends Error {
+  constructor(found) {
+    super(
+      `The shared drawing uses schema version ${String(found)}; this build reads version ${SCHEMA_VERSION}.`
+    );
+    this.found = found;
+    this.name = "SchemaVersionError";
+  }
+  found;
+};
 var META = "visio:meta";
 var PAGES = "visio:pages";
 var BODIES = "visio:bodies";
 var SHAPES = "visio:shapes";
+var CELLS = "visio:cells";
 var CONNECTS = "visio:connects";
 var DEAD = "visio:dead";
+var MASTERS = "visio:masters";
+var RENUM = "visio:renum";
+var MEDIA = "visio:media";
+var BLOBS = "visio:blobs";
 var PARTS = "visio:parts";
 var REL_MARK = "<!--@rel-->";
 var SHAPES_MARK = "<!--@shapes-->";
@@ -335,8 +651,13 @@ function sharedDrawing(doc) {
     pages: doc.getMap(PAGES),
     bodies: doc.getMap(BODIES),
     shapes: doc.getMap(SHAPES),
+    cells: doc.getMap(CELLS),
     connects: doc.getMap(CONNECTS),
     dead: doc.getMap(DEAD),
+    masters: doc.getMap(MASTERS),
+    renum: doc.getMap(RENUM),
+    media: doc.getMap(MEDIA),
+    blobs: doc.getMap(BLOBS),
     parts: doc.getMap(PARTS)
   };
 }
@@ -345,17 +666,27 @@ var sharedTypes = (shared) => [
   shared.pages,
   shared.bodies,
   shared.shapes,
+  shared.cells,
   shared.connects,
   shared.dead,
+  shared.masters,
+  shared.renum,
+  shared.media,
+  shared.blobs,
   shared.parts
 ];
 var isSharedDrawingEmpty = (shared) => shared.pages.size === 0 && shared.meta.get("v") === void 0;
+function assertSchemaVersion(shared) {
+  const v = shared.meta.get("v");
+  if (v !== void 0 && v !== SCHEMA_VERSION) throw new SchemaVersionError(v);
+}
 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]);
+  const same = (x, y) => x === y || Array.isArray(x) && Array.isArray(y) && JSON.stringify(x) === JSON.stringify(y);
+  return ka.length === kb.length && ka.every((k) => same(a[k], b[k]));
 }
 function setIfChanged(map, key, value) {
   if (sameRecord(map.get(key), value)) return false;
@@ -364,27 +695,53 @@ function setIfChanged(map, key, value) {
 }
 var str = (value) => typeof value === "string" ? value : void 0;
 var num = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var opt = (key, value) => value === void 0 ? {} : { [key]: value };
 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 } : {} };
+  return { pos, id, xml, ...opt("back", str(value.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 } : {} };
+  return { shell, ...opt("rels", str(value.rels)), ...opt("b", str(value.b)) };
 }
 function shapeEntry(value) {
+  if (!isRecord(value)) return void 0;
+  const pos = num(value.pos);
+  const open = str(value.open);
+  if (pos === void 0 || open === void 0) return void 0;
+  return { pos, open, ...opt("parent", str(value.parent)), ...opt("b", str(value.b)) };
+}
+function cellEntry(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 };
+  const open = str(value.open);
+  if (pos === void 0 || xml === void 0 && open === void 0) return void 0;
+  return { pos, ...opt("xml", xml), ...opt("open", xml === void 0 ? open : void 0) };
+}
+function masterEntry(value) {
+  if (!isRecord(value)) return void 0;
+  const pos = num(value.pos);
+  const id = str(value.id);
+  const xml = str(value.xml);
+  const part = str(value.part);
+  if (pos === void 0 || id === void 0 || xml === void 0 || part === void 0)
+    return void 0;
+  return { pos, id, xml, part, ...opt("rels", str(value.rels)), ...opt("b", str(value.b)) };
+}
+function mediaEntry(value) {
+  if (!isRecord(value)) return void 0;
+  const path = str(value.path);
+  const hash = str(value.hash);
+  const ct = str(value.ct);
+  if (path === void 0 || hash === void 0 || ct === void 0) return void 0;
+  return { path, hash, ct, d: value.d === true, ...opt("b", str(value.b)) };
 }
 function connectEntry(value) {
   if (!isRecord(value)) return void 0;
@@ -396,11 +753,15 @@ function connectEntry(value) {
   }
   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 renumEntry(value) {
+  if (!isRecord(value)) return void 0;
+  const pair = (v) => Array.isArray(v) && v.length === 2 && typeof v[0] === "string" && typeof v[1] === "string" ? [v[0], v[1]] : void 0;
+  const i = pair(value.i);
+  const m = pair(value.m);
+  return i || m ? { ...i ? { i } : {}, ...m ? { m } : {} } : void 0;
 }
+
+// visio/collab/snapshot-contents.ts
 function splitList(text, name, mark, child) {
   const box = scanContainer(text, name);
   if (!box) return { text, items: [] };
@@ -416,6 +777,46 @@ function splitList(text, name, mark, child) {
   }
   return { text: text.slice(0, box.openEnd) + mark + text.slice(box.closeStart), items };
 }
+function flatten(xml, parent, page, keys, out) {
+  const split2 = splitShape(xml);
+  const id = split2 ? attrOf(split2.open, "ID") : void 0;
+  if (!split2 || id === void 0) return;
+  const key = keys.shapeKey(page, id);
+  out.push({
+    key,
+    id,
+    ...parent !== void 0 ? { parent } : {},
+    open: split2.open,
+    pieces: split2.pieces
+  });
+  for (const nested of split2.nested) flatten(nested, key, page, keys, out);
+}
+function splitContents(content, scope, keys) {
+  const shapesSplit = splitList(content, "Shapes", SHAPES_MARK, "Shape");
+  const connectsSplit = splitList(shapesSplit.text, "Connects", CONNECTS_MARK, "Connect");
+  const shapes = [];
+  for (const text of shapesSplit.items) flatten(text, void 0, scope, keys, shapes);
+  const owner = new Map(shapes.map((s) => [s.id, s.key]));
+  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: `${scope}/${entry.fk}.${entry.fi}.${entry.fc}.${entry.fp}>${entry.tk}.${entry.ti}.${entry.tc}.${entry.tp}`,
+      entry
+    });
+  }
+  return { shell: connectsSplit.text, shapes, connects };
+}
 var readZip = (bytes) => JSZip__default.default.loadAsync(bytes);
 var zipText = async (zip, path) => zip.file(path)?.async("string");
 async function readLayout(zip) {
@@ -426,19 +827,25 @@ async function readLayout(zip) {
   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;
+  const masters = rels.find((r) => r.type.endsWith("/masters"));
+  const dir = dirName(documentPath);
+  return pages ? {
+    documentPath,
+    pagesPath: resolveTarget(dir, pages.target),
+    ...masters ? { mastersPath: resolveTarget(dir, masters.target) } : {}
+  } : void 0;
 }
-async function readLocalPages(zip, layout, pagesXml) {
-  const box = scanContainer(pagesXml, "Pages");
+async function readLocalItems(zip, listPath, xml, container, child) {
+  const box = scanContainer(xml, container);
   if (!box) return void 0;
   const rels = new Map(
-    parseRelationships(await zipText(zip, relsPathOf(layout.pagesPath))).map((r) => [r.id, r])
+    parseRelationships(await zipText(zip, relsPathOf(listPath))).map((r) => [r.id, r])
   );
-  const pages = [];
+  const items = [];
   for (const span of box.children) {
-    if (span.name !== "Page") continue;
-    const text = pagesXml.slice(span.start, span.end);
-    const inner = scanContainer(text, "Page");
+    if (span.name !== child) continue;
+    const text = xml.slice(span.start, span.end);
+    const inner = scanContainer(text, child);
     const relSpan = inner?.children.find((c) => c.name === "Rel");
     if (!inner || !relSpan) return void 0;
     const relTag = text.slice(relSpan.start, relSpan.openEnd);
@@ -446,239 +853,194 @@ async function readLocalPages(zip, layout, pagesXml) {
     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({
+    items.push({
       id,
       text,
-      path: resolveTarget(dirName(layout.pagesPath), target),
+      path: resolveTarget(dirName(listPath), target),
       rel: { start: relSpan.start, end: relSpan.end }
     });
   }
-  return { box, pages };
+  return { box, items };
+}
+var withMark = (item) => item.text.slice(0, item.rel.start) + REL_MARK + item.text.slice(item.rel.end);
+
+// visio/collab/snapshot-parts.ts
+async function snapshotMasters(zip, layout, keys, derived) {
+  const masters = [];
+  let mastersOpen;
+  let mastersClose;
+  if (layout.mastersPath) {
+    const listXml = await zipText(zip, layout.mastersPath) ?? "";
+    const list = await readLocalItems(zip, layout.mastersPath, listXml, "Masters", "Master");
+    if (list) {
+      derived.add(layout.mastersPath).add(relsPathOf(layout.mastersPath));
+      mastersOpen = listXml.slice(0, list.box.openEnd);
+      mastersClose = listXml.slice(list.box.closeStart);
+      for (const item of list.items) {
+        const content = await zipText(zip, item.path);
+        if (content === void 0) continue;
+        derived.add(item.path).add(relsPathOf(item.path));
+        const key = keys.masterKey(item.id);
+        keys.masterPaths.set(key, item.path);
+        const rels = await zipText(zip, relsPathOf(item.path));
+        const { shell, shapes, connects } = splitContents(content, masterScope(key), keys);
+        masters.push({
+          key,
+          id: item.id,
+          xml: withMark(item),
+          path: item.path,
+          part: encoder.encode(shell),
+          ...rels !== void 0 ? { rels } : {},
+          shapes,
+          connects
+        });
+      }
+    }
+  }
+  return { masters, mastersOpen, mastersClose };
+}
+async function snapshotRest(zip, derived, limit) {
+  const parts = /* @__PURE__ */ new Map();
+  const media = [];
+  const typesXml = await zipText(zip, CONTENT_TYPES) ?? "";
+  const mediaPaths = /* @__PURE__ */ new Set();
+  let total = 0;
+  for (const path of Object.keys(zip.files)) {
+    const file = zip.files[path];
+    if (file.dir || derived.has(path) || isLocalOnlyPart(path)) continue;
+    const data = await file.async("uint8array");
+    total += data.length;
+    if (total > limit) throw new Error("The package parts exceed the shared size limit.");
+    const declared = isMediaPart(path) ? declaredType(typesXml, path) : void 0;
+    if (declared) {
+      mediaPaths.add(path);
+      media.push({
+        path,
+        hash: contentHash(data),
+        ct: declared.type,
+        d: declared.byDefault,
+        data
+      });
+    } else parts.set(path, data);
+  }
+  const types = parts.get(CONTENT_TYPES);
+  if (types)
+    parts.set(
+      CONTENT_TYPES,
+      encoder.encode(
+        stripOverrides(decoder.decode(types), [PAGE_CONTENT_TYPE, MASTER_CONTENT_TYPE], mediaPaths)
+      )
+    );
+  return { parts, media };
 }
+
+// visio/collab/snapshot.ts
+var DEFAULT_MAX_PART_BYTES = 48 * 1024 * 1024;
 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);
+  const local = await readLocalItems(zip, layout.pagesPath, pagesXml, "Pages", "Page");
   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 idToKey = new Map(local.items.map((p) => [p.id, keys.pageKey(p.id)]));
   const pages = [];
-  for (const page of local.pages) {
+  for (const page of local.items) {
     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
-      });
-    }
+    const { shell, shapes, connects } = splitContents(content, key, keys);
     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,
+      xml: withMark(page),
+      shell,
       ...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);
-  }
+  const { masters, mastersOpen, mastersClose } = await snapshotMasters(zip, layout, keys, derived);
+  const { parts, media } = await snapshotRest(
+    zip,
+    derived,
+    options.maxPartBytes ?? DEFAULT_MAX_PART_BYTES
+  );
   return {
     pagesPath: layout.pagesPath,
     pagesOpen: pagesXml.slice(0, local.box.openEnd),
     pagesClose: pagesXml.slice(local.box.closeStart),
     pages,
+    ...mastersOpen !== void 0 && mastersClose !== void 0 && layout.mastersPath ? { mastersPath: layout.mastersPath, mastersOpen, mastersClose } : {},
+    masters,
+    media,
     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);
+// visio/collab/compose-lists.ts
+var relTarget = (dir, path) => dir && path.startsWith(`${dir}/`) ? path.slice(dir.length + 1) : `/${path}`;
+async function placeList(options) {
+  const { files, taken, localZip, items } = options;
+  const dir = dirName(options.listPath);
+  taken.add(options.listPath).add(relsPathOf(options.listPath));
+  const paths = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const known = options.known.get(item.key);
+    if (known && !taken.has(known) && localZip?.file(known)) {
+      paths.set(item.key, known);
+      taken.add(known);
     }
   }
-  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++;
-    }
+  let counter = 0;
+  for (const item of items) {
+    if (paths.has(item.key)) continue;
+    let path;
+    do
+      path = `${dir ? `${dir}/` : ""}${options.stem}${++counter}.xml`;
+    while (taken.has(path) || localZip?.file(path));
+    paths.set(item.key, path);
+    taken.add(path);
   }
-  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);
+  const others = parseRelationships(
+    localZip ? await zipText(localZip, relsPathOf(options.listPath)) : void 0
+  ).filter((r) => r.type !== options.relType);
+  const usedIds = new Set(others.map((r) => r.id));
+  let nextRel = 0;
+  const rels = [];
+  const elements = [];
+  for (const item of items) {
+    const path = paths.get(item.key);
+    let id;
+    do
+      id = `rId${++nextRel}`;
+    while (usedIds.has(id));
+    usedIds.add(id);
+    rels.push(
+      `<Relationship Id="${id}" Type="${options.relType}" Target="${escapeAttr(relTarget(dir, path))}"/>`
+    );
+    const rel = `<Rel xmlns:r="${REL_NS}" r:id="${id}"/>`;
+    elements.push(
+      item.xml.includes(REL_MARK) ? item.xml.replace(REL_MARK, () => rel) : item.xml.slice(0, item.xml.lastIndexOf("</")) + rel + item.xml.slice(item.xml.lastIndexOf("</"))
+    );
+    files.set(path, item.part);
+    if (item.rels !== void 0) files.set(relsPathOf(path), encoder.encode(item.rels));
   }
-  for (const path of [...keys.partPrints.keys()])
-    if (!snapshot.parts.has(path)) {
-      shared.parts.delete(path);
-      keys.partPrints.delete(path);
-      writes++;
-    }
-  return writes;
+  files.set(options.listPath, encoder.encode(options.open + elements.join("") + options.close));
+  files.set(
+    relsPathOf(options.listPath),
+    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("") + rels.join("") + "</Relationships>"
+    )
+  );
+  return paths;
 }
 
 // visio/collab/compose.ts
@@ -694,32 +1056,51 @@ function connectXml(item) {
   ];
   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}`;
+function contentsXml(shell, root, shapesXml, hasShapes, connects) {
+  const outer = scanContainer(shell, root);
+  if (hasShapes && !shell.includes(SHAPES_MARK) && outer && !outer.selfClosing)
+    shell = shell.slice(0, outer.openEnd) + `<Shapes>${SHAPES_MARK}</Shapes>` + shell.slice(outer.openEnd);
+  const outer2 = scanContainer(shell, root);
+  if (connects.length && !shell.includes(CONNECTS_MARK) && outer2 && !outer2.selfClosing)
+    shell = shell.slice(0, outer2.closeStart) + `<Connects>${CONNECTS_MARK}</Connects>` + shell.slice(outer2.closeStart);
+  return shell.replace(SHAPES_MARK, () => shapesXml).replace(CONNECTS_MARK, () => connects.map(connectXml).join(""));
 }
+var pagePartXml = (page) => contentsXml(
+  page.body.shell,
+  "PageContents",
+  page.shapesXml,
+  page.shapes.length > 0,
+  page.connects
+);
+var masterPartXml = (master) => contentsXml(
+  decoder.decode(fromBase64(master.part)),
+  "MasterContents",
+  master.shapesXml,
+  master.shapes.length > 0,
+  master.connects
+);
 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);
+  const cache = keys.cache.parts;
+  const decode = (path, b64) => {
+    const hit = cache.get(path);
+    const data = hit && hit.b64 === b64 ? hit.data : fromBase64(b64);
+    if (!hit || hit.b64 !== b64) cache.set(path, { b64, data });
     total += data.length;
     if (total > limit) throw new Error("The shared parts exceed the size limit.");
+    return data;
+  };
+  for (const [path, b64] of drawing.parts) {
+    const data = decode(path, b64);
     files.set(path, data);
     prints.set(path, fingerprint(data));
   }
+  for (const path of [...cache.keys()])
+    if (!drawing.parts.has(path) && !path.startsWith("media:")) cache.delete(path);
   if (localZip)
     for (const path of Object.keys(localZip.files)) {
       const file = localZip.files[path];
@@ -727,6 +1108,10 @@ async function composeDrawing(drawing, local, keys, options = {}) {
         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 item of drawing.media) {
+    files.set(item.path, decode(`media:${item.path}`, item.data));
+    contentTypes = ensureType(contentTypes, item.path, item.declared);
+  }
   for (const [path, data] of [...files]) {
     if (!path.endsWith(".rels") || typeof data === "string") continue;
     const source = path.replace(/(^|\/)_rels\/([^/]+)\.rels$/, "$1$2");
@@ -745,65 +1130,56 @@ async function composeDrawing(drawing, local, keys, options = {}) {
     });
     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));
+  const taken = new Set(files.keys());
+  const pageCache = keys.cache.pageParts;
+  const pageItems = drawing.pages.map((page) => {
+    const hit = pageCache.get(page.key);
+    const bytes2 = hit && hit.sig === page.signature ? hit.bytes : encoder.encode(pagePartXml(page));
+    pageCache.set(page.key, { sig: page.signature, bytes: bytes2 });
+    return {
+      key: page.key,
+      xml: page.xml,
+      part: bytes2,
+      ...page.body.rels !== void 0 ? { rels: page.body.rels } : {}
+    };
+  });
+  for (const key of [...pageCache.keys()])
+    if (!drawing.pages.some((p) => p.key === key)) pageCache.delete(key);
+  const pagePaths = await placeList({
+    listPath: drawing.pagesPath,
+    open: drawing.pagesOpen,
+    close: drawing.pagesClose,
+    relType: PAGE_TYPE,
+    stem: "page",
+    items: pageItems,
+    known: keys.pagePaths,
+    files,
+    taken,
+    localZip
+  });
+  contentTypes = withPageOverrides(contentTypes, [...pagePaths.values()]);
+  let masterPaths = /* @__PURE__ */ new Map();
+  if (drawing.mastersPath !== void 0) {
+    masterPaths = await placeList({
+      listPath: drawing.mastersPath,
+      open: drawing.mastersOpen ?? "<Masters>",
+      close: drawing.mastersClose ?? "</Masters>",
+      relType: MASTER_TYPE,
+      stem: "master",
+      items: drawing.masters.map((m) => ({
+        key: m.key,
+        xml: m.xml,
+        part: encoder.encode(masterPartXml(m)),
+        ...m.rels !== void 0 ? { rels: m.rels } : {}
+      })),
+      known: keys.masterPaths,
+      files,
+      taken,
+      localZip
+    });
+    contentTypes = withOverrides(contentTypes, MASTER_CONTENT_TYPE, [...masterPaths.values()]);
   }
-  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()])));
+  files.set(CONTENT_TYPES, encoder.encode(contentTypes));
   const zip = new JSZip__default.default();
   const names = [...files.keys()].sort(
     (a, b) => a === CONTENT_TYPES ? -1 : b === CONTENT_TYPES ? 1 : 0
@@ -812,24 +1188,58 @@ async function composeDrawing(drawing, local, keys, options = {}) {
   const bytes = await zip.generateAsync({ type: "uint8array", compression: "STORE" });
   const commit = () => {
     const pageIds = /* @__PURE__ */ new Map();
-    const shapeIds2 = /* @__PURE__ */ new Map();
+    const shapeIds = /* @__PURE__ */ new Map();
+    const masterIds = /* @__PURE__ */ new Map();
     const known = /* @__PURE__ */ new Map();
+    const recordShapes = (scope, shapes, connects) => {
+      shapeIds.set(scope, new Map(shapes.map((s) => [s.id, s.key])));
+      for (const shape of shapes) {
+        known.set(shapeId(scope, shape.key), shellContent(shape));
+        for (const [path, entry] of shape.entries)
+          known.set(cellId(scope, shape.key, path), entryContent(entry));
+      }
+      for (const connect of connects) known.set(connectId(connect.key), "");
+    };
     keys.pagePaths.clear();
+    keys.masterPaths.clear();
+    keys.mediaKeys.clear();
     for (const page of drawing.pages) {
       pageIds.set(page.id, page.key);
-      keys.pagePaths.set(page.key, paths.get(page.key));
+      keys.pagePaths.set(page.key, pagePaths.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), "");
+      recordShapes(page.key, page.shapes, page.connects);
+    }
+    for (const master of drawing.masters) {
+      masterIds.set(master.id, master.key);
+      recordShapes(masterScope(master.key), master.shapes, master.connects);
+      const path = masterPaths.get(master.key);
+      if (path) keys.masterPaths.set(master.key, path);
+      known.set(
+        masterId(master.key),
+        masterContent({ ...master, print: fingerprint(fromBase64(master.part)) })
+      );
     }
-    keys.reset(pageIds, shapeIds2);
+    for (const item of drawing.media) {
+      known.set(mediaId(item.key), "");
+      keys.mediaKeys.set(item.path, item.key);
+    }
+    keys.reset(pageIds, shapeIds, masterIds);
     keys.known = known;
     keys.partPrints.clear();
     for (const [path, print] of prints) keys.partPrints.set(path, print);
   };
-  return { bytes, commit };
+  return { bytes, signature: drawing.signature, commit };
+}
+
+// visio/collab/fixups.ts
+function applyFixups(shared, fixups) {
+  let changed = 0;
+  for (const fixup of fixups) {
+    const map = fixup.map === "renum" ? shared.renum : shared.cells;
+    if (setIfChanged(map, fixup.key, fixup.value)) changed++;
+  }
+  return changed;
 }
 
 // visio/collab/keys.ts
@@ -843,15 +1253,34 @@ var DrawingKeys = class {
   seeding = false;
   #pages = /* @__PURE__ */ new Map();
   #shapes = /* @__PURE__ */ new Map();
+  #masters = /* @__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();
+  /** The part path of each master key in the local package. */
+  masterPaths = /* @__PURE__ */ new Map();
+  /** The room key of each media path in the local package. */
+  mediaKeys = /* @__PURE__ */ new Map();
+  /** Serialised page parts and decoded shared parts of the last rebuild, to skip unchanged work. */
+  cache = {
+    pageParts: /* @__PURE__ */ new Map(),
+    parts: /* @__PURE__ */ new Map()
+  };
+  /**
+   * What was last applied to the editor: the drawing signature, the editor version it produced,
+   * the signature of everything but page content and the content signature of each page.
+   */
+  applied;
   mint() {
     return `${this.tag}.${(++this.#counter).toString(36)}`;
   }
+  /** A fresh id for one write batch: entries written together share it. */
+  batch() {
+    return this.mint();
+  }
   pageKey(id) {
     let key = this.#pages.get(id);
     if (key === void 0) {
@@ -870,6 +1299,14 @@ var DrawingKeys = class {
     }
     return key;
   }
+  masterKey(id) {
+    let key = this.#masters.get(id);
+    if (key === void 0) {
+      key = this.seeding ? `s${id}` : this.mint();
+      this.#masters.set(id, key);
+    }
+    return key;
+  }
   findPage(id) {
     return this.#pages.get(id);
   }
@@ -883,38 +1320,355 @@ var DrawingKeys = class {
       for (const [id, k] of map) if (k === key) map.delete(id);
     }
   }
+  forgetMaster(key) {
+    for (const [id, k] of this.#masters) if (k === key) this.#masters.delete(id);
+    this.#shapes.delete(masterScope(key));
+    this.masterPaths.delete(key);
+  }
   /** Replaces the id-to-key tables with those of a freshly composed package. */
-  reset(pages, shapes) {
+  reset(pages, shapes, masters = /* @__PURE__ */ new Map()) {
     this.#pages.clear();
     this.#shapes.clear();
+    this.#masters.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));
+    for (const [id, key] of masters) this.#masters.set(id, key);
   }
 };
 
-// visio/collab/read.ts
+// 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/read-ids.ts
 var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 var numeric = (id) => /^\d+$/.test(id) ? Number(id) : 0;
+function assignIds(items) {
+  const effective = (item) => item.fixed ?? item.id;
+  let max = Math.max(0, ...items.map((item) => numeric(effective(item))));
+  const order = [...items].sort(
+    (a, b) => Number(b.fixed !== void 0) - Number(a.fixed !== void 0) || compare(a.key, b.key)
+  );
+  const used = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Map();
+  const fresh = /* @__PURE__ */ new Map();
+  for (const item of order) {
+    let id = effective(item);
+    if (used.has(id)) {
+      id = String(++max);
+      fresh.set(item.key, { from: item.id, to: id });
+    }
+    used.add(id);
+    ids.set(item.key, id);
+  }
+  return { ids, fresh };
+}
+var fixedId = (renum, key, id) => {
+  const pair = renum.get(key)?.i;
+  return pair && pair[0] === id ? pair[1] : void 0;
+};
+function readRenum(shared) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, value] of shared.renum) {
+    const entry = renumEntry(value);
+    if (entry) out.set(key, entry);
+  }
+  return out;
+}
+
+// visio/collab/read-util.ts
+function hashTexts(texts) {
+  let a = 2166136261;
+  let b = 16777619 ^ 2654435769;
+  for (const text of texts) {
+    for (let i = 0; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      a = Math.imul(a ^ c, 16777619);
+      b = Math.imul(b + c, 2246822507) ^ b >>> 13;
+    }
+    a = Math.imul(a ^ 255, 16777619);
+    b = Math.imul(b ^ 255, 3266489909);
+  }
+  return `${(a >>> 0).toString(16)}${(b >>> 0).toString(16)}`;
+}
+var split = (key, depth) => {
+  const out = [];
+  let from = 0;
+  for (let i = 0; i < depth; i++) {
+    const slash = key.indexOf("/", from);
+    if (slash < 0) return void 0;
+    out.push(key.slice(from, slash));
+    from = slash + 1;
+  }
+  out.push(key.slice(from));
+  return out;
+};
+var connectSignature = (connects) => connects.flatMap((c) => [c.from, c.to, c.entry.fc, c.entry.tc, c.entry.fp, c.entry.tp]);
+function resolveConnects(list, shapes) {
+  const byKey = new Map(shapes.map((s) => [s.key, s]));
+  const out = [];
+  for (const item of [...list ?? []].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;
+    out.push({ key: item.key, entry, from: from?.id ?? entry.fi, to: to?.id ?? entry.ti });
+  }
+  return out;
+}
+
+// visio/collab/read-shapes.ts
 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) => {
+function renumberFormulas(xml, remap) {
+  if (!remap.size || !xml.includes("Sheet.")) return xml;
+  return xml.replace(/(\sF\s*=\s*)("[^"]*"|'[^']*')/g, (_m, head, value) => {
+    const body = value.slice(1, -1).replace(/Sheet\.(\d+)(?!\d)/g, (m, id) => {
       const next = remap.get(id);
-      return next === void 0 ? m : `${head}${q}${next}${q}`;
+      return next === void 0 ? m : `Sheet.${next}`;
+    });
+    return `${head}${value[0]}${body}${value[0]}`;
+  });
+}
+function resolveShapes(input) {
+  const raw = /* @__PURE__ */ new Map();
+  for (const [key, entry] of input.shapes) {
+    const id = attrOf(entry.open, "ID");
+    if (id !== void 0) raw.set(key, { entry, id });
+  }
+  const state = /* @__PURE__ */ new Map();
+  const valid = (key, seen = /* @__PURE__ */ new Set()) => {
+    const known = state.get(key);
+    if (known !== void 0) return known;
+    const item = raw.get(key);
+    const parent = item?.entry.parent;
+    let ok = !!item;
+    if (ok && parent !== void 0) ok = !seen.has(key) && valid(parent, seen.add(key));
+    state.set(key, ok);
+    return ok;
+  };
+  const live = [...raw.keys()].filter((k) => valid(k)).sort(compare);
+  const { ids: finalId, fresh: renumbered } = assignIds(
+    live.map((key) => {
+      const { id } = raw.get(key);
+      return { key, id, fixed: fixedId(input.renum, key, id) };
     })
-  ).replace(/Sheet\.(\d+)(?!\d)/g, (m, id) => {
-    const next = remap.get(id);
-    return next === void 0 ? m : `Sheet.${next}`;
+  );
+  const batchRemap = /* @__PURE__ */ new Map();
+  for (const [key, change] of renumbered) {
+    const b = raw.get(key).entry.b;
+    if (b === void 0) continue;
+    const map = batchRemap.get(b) ?? /* @__PURE__ */ new Map();
+    map.set(change.from, change.to);
+    batchRemap.set(b, map);
+  }
+  const remapFor = (key) => {
+    const out = new Map(batchRemap.get(raw.get(key).entry.b ?? "") ?? []);
+    const chain = [];
+    for (let k = key; k !== void 0; k = raw.get(k)?.entry.parent)
+      chain.unshift(k);
+    for (const k of chain) {
+      const change = renumbered.get(k);
+      if (change) out.set(change.from, change.to);
+    }
+    return out;
+  };
+  const children = /* @__PURE__ */ new Map();
+  for (const key of live) {
+    const parent = raw.get(key).entry.parent ?? "";
+    children.set(parent, [...children.get(parent) ?? [], key]);
+  }
+  const sortSiblings = (keys) => keys.sort((a, b) => raw.get(a).entry.pos - raw.get(b).entry.pos || compare(a, b));
+  const shapes = [];
+  const fixups = [];
+  const render = (key) => {
+    const { entry } = raw.get(key);
+    const id = finalId.get(key);
+    const remap = remapFor(key);
+    let open = setAttr(entry.open, "ID", id);
+    const record = { ...input.renum.get(key) };
+    let dirty = false;
+    const change = renumbered.get(key);
+    if (change) {
+      record.i = [change.from, change.to];
+      dirty = true;
+    }
+    const master = attrOf(open, "Master");
+    const persisted = record.m && record.m[0] === master ? record.m[1] : void 0;
+    const batched = master !== void 0 ? input.masterRemap.get(entry.b ?? "")?.get(master) : void 0;
+    const next = persisted ?? batched;
+    if (next !== void 0) open = setAttr(open, "Master", next);
+    if (persisted === void 0 && batched !== void 0) {
+      record.m = [master, batched];
+      dirty = true;
+    }
+    if (dirty) fixups.push({ map: "renum", key: `${input.scope}/${key}`, value: record });
+    const entries = /* @__PURE__ */ new Map();
+    for (const [path, piece] of input.cells.get(key) ?? []) {
+      const leaf = piece.xml !== void 0 && /(^|\/)c\/[^/]*$/.test(path);
+      const xml2 = leaf ? renumberFormulas(piece.xml, remap) : void 0;
+      if (xml2 !== void 0 && xml2 !== piece.xml) {
+        const value = { ...piece, xml: xml2 };
+        entries.set(path, value);
+        fixups.push({ map: "cells", key: `${input.scope}/${key}/${path}`, value });
+      } else entries.set(path, piece);
+    }
+    shapes.push({
+      key,
+      id,
+      ...entry.parent !== void 0 ? { parent: entry.parent } : {},
+      open,
+      entries
+    });
+    const inner = sortSiblings(children.get(key) ?? []).map(render).join("");
+    return buildShape(open, entries, inner ? `<Shapes>${inner}</Shapes>` : "");
+  };
+  const xml = sortSiblings(children.get("") ?? []).map(render).join("");
+  return { shapes, xml, fixups };
+}
+
+// visio/collab/read-parts.ts
+var compare2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function resolveMasters(shared, renum) {
+  const alive = [];
+  for (const [key, value] of shared.masters) {
+    const entry = masterEntry(value);
+    if (entry) alive.push({ key, entry });
+  }
+  const { ids, fresh } = assignIds(
+    alive.map(({ key, entry }) => ({
+      key,
+      id: entry.id,
+      fixed: fixedId(renum, masterScope(key), entry.id)
+    }))
+  );
+  const remap = /* @__PURE__ */ new Map();
+  const fixups = [];
+  for (const [key, change] of [...fresh].sort((a, b) => compare2(a[0], b[0]))) {
+    const b = alive.find((m) => m.key === key).entry.b;
+    if (b !== void 0) {
+      const map = remap.get(b) ?? /* @__PURE__ */ new Map();
+      map.set(change.from, change.to);
+      remap.set(b, map);
+    }
+    fixups.push({
+      map: "renum",
+      key: masterScope(key),
+      value: { ...renum.get(masterScope(key)), i: [change.from, change.to] }
+    });
+  }
+  alive.sort((a, b) => a.entry.pos - b.entry.pos || compare2(a.key, b.key));
+  return {
+    masters: alive.map(({ key, entry }) => {
+      const id = ids.get(key);
+      const open = /^<[^>]*>/.exec(entry.xml)?.[0];
+      return {
+        key,
+        id,
+        xml: open ? setAttr(open, "ID", id) + entry.xml.slice(open.length) : entry.xml,
+        part: entry.part,
+        ...entry.rels !== void 0 ? { rels: entry.rels } : {}
+      };
+    }),
+    remap,
+    fixups
+  };
+}
+function resolveMedia(shared) {
+  const items = [...shared.media].flatMap(([key, value]) => {
+    const entry = mediaEntry(value);
+    const data = entry ? str(shared.blobs.get(entry.hash)) : void 0;
+    return entry && data !== void 0 ? [{ key, entry, data }] : [];
+  }).sort((a, b) => compare2(a.key, b.key));
+  const taken = /* @__PURE__ */ new Set();
+  const first = /* @__PURE__ */ new Map();
+  for (const item of items) if (!first.has(item.entry.path)) first.set(item.entry.path, item.key);
+  for (const path of first.keys()) taken.add(path);
+  const renames = /* @__PURE__ */ new Map();
+  const media = [];
+  for (const { key, entry, data } of items) {
+    let path = entry.path;
+    if (first.get(entry.path) !== key) {
+      const dot = path.lastIndexOf(".");
+      const stem = dot > path.lastIndexOf("/") ? path.slice(0, dot) : path;
+      const ext = dot > path.lastIndexOf("/") ? path.slice(dot) : "";
+      path = `${stem}-${entry.hash.slice(0, 8)}${ext}`;
+      for (let n = 2; taken.has(path); n++) path = `${stem}-${entry.hash.slice(0, 8)}-${n}${ext}`;
+      taken.add(path);
+      if (entry.b !== void 0) {
+        const map = renames.get(entry.b) ?? /* @__PURE__ */ new Map();
+        map.set(entry.path, path);
+        renames.set(entry.b, map);
+      }
+    }
+    media.push({
+      key,
+      path,
+      hash: entry.hash,
+      declared: { type: entry.ct, byDefault: entry.d },
+      data
+    });
+  }
+  return { media, renames };
+}
+function renameTargets(rels, baseDir, renames) {
+  return rels.replace(/<(?:\w+:)?Relationship\b[^>]*>/g, (tag) => {
+    const target = attrOf(tag, "Target");
+    if (target === void 0 || attrOf(tag, "TargetMode") === "External") return tag;
+    const next = renames.get(resolveTarget(baseDir, target));
+    if (next === void 0) return tag;
+    const value = target.startsWith("/") ? `/${next}` : relativeTarget(baseDir, next);
+    return tag.replace(
+      /(\sTarget\s*=\s*)(?:"[^"]*"|'[^']*')/,
+      (_m, head) => `${head}"${value}"`
+    );
   });
 }
+
+// visio/collab/read.ts
 function readSharedDrawing(shared) {
+  assertSchemaVersion(shared);
   if (isSharedDrawingEmpty(shared)) return void 0;
   const pagesPath = str(shared.meta.get("pagesPath"));
   const pagesOpen = str(shared.meta.get("pagesOpen"));
@@ -926,25 +1680,50 @@ function readSharedDrawing(shared) {
     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 renum = readRenum(shared);
+  const fixups = [];
+  const { ids: pageIds, fresh: freshPages } = assignIds(
+    alive.map((p) => ({
+      key: p.key,
+      id: p.entry.id,
+      fixed: fixedId(renum, p.key, p.entry.id)
+    }))
+  );
+  for (const [key, change] of [...freshPages].sort((a, b) => compare(a[0], b[0])))
+    fixups.push({
+      map: "renum",
+      key,
+      value: { ...renum.get(key), i: [change.from, change.to] }
+    });
   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 parts2 = split(full, 1);
+    if (!parts2 || 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 map = shapesByPage.get(parts2[0]) ?? /* @__PURE__ */ new Map();
+    map.set(parts2[1], entry);
+    shapesByPage.set(parts2[0], map);
+  }
+  const cellsByPage = /* @__PURE__ */ new Map();
+  for (const [full, value] of shared.cells) {
+    const parts2 = split(full, 2);
+    const entry = parts2 && cellEntry(value);
+    if (!parts2 || !entry) continue;
+    const [page, shape, path] = parts2;
+    const shapes = cellsByPage.get(page) ?? /* @__PURE__ */ new Map();
+    const cells = shapes.get(shape) ?? /* @__PURE__ */ new Map();
+    cells.set(path, entry);
+    shapes.set(shape, cells);
+    cellsByPage.set(page, shapes);
+  }
+  const renumByScope = /* @__PURE__ */ new Map();
+  for (const [full, entry] of renum) {
+    const parts2 = split(full, 1);
+    if (!parts2) continue;
+    const map = renumByScope.get(parts2[0]) ?? /* @__PURE__ */ new Map();
+    map.set(parts2[1], entry);
+    renumByScope.set(parts2[0], map);
   }
   const connectsByPage = /* @__PURE__ */ new Map();
   for (const [full, value] of shared.connects) {
@@ -955,24 +1734,25 @@ function readSharedDrawing(shared) {
     list.push({ key: full, entry });
     connectsByPage.set(full.slice(0, slash), list);
   }
+  const { masters, remap: masterRemap, fixups: masterFixups } = resolveMasters(shared, renum);
+  fixups.push(...masterFixups);
+  const { media, renames } = resolveMedia(shared);
+  const mastersPath = str(shared.meta.get("mastersPath"));
+  const mastersOpen = str(shared.meta.get("mastersOpen"));
+  const mastersClose = str(shared.meta.get("mastersClose"));
+  const pagesDir = dirName(pagesPath);
   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
-      });
-    }
+    const resolved = resolveShapes({
+      scope: page.key,
+      shapes: shapesByPage.get(page.key) ?? /* @__PURE__ */ new Map(),
+      cells: cellsByPage.get(page.key) ?? /* @__PURE__ */ new Map(),
+      renum: renumByScope.get(page.key) ?? /* @__PURE__ */ new Map(),
+      masterRemap
+    });
+    fixups.push(...resolved.fixups);
+    const connects = resolveConnects(connectsByPage.get(page.key), resolved.shapes);
     let xml = page.entry.xml;
     const open = /^<[^>]*>/.exec(xml)?.[0];
     if (open) {
@@ -981,46 +1761,360 @@ function readSharedDrawing(shared) {
       if (back !== void 0) next = setAttr(next, "BackPage", back);
       xml = next + xml.slice(open.length);
     }
+    const rename = page.body.b !== void 0 ? renames.get(page.body.b) : void 0;
+    const body = rename && page.body.rels !== void 0 ? { ...page.body, rels: renameTargets(page.body.rels, pagesDir, rename) } : page.body;
+    const contentSignature = hashTexts([
+      body.shell,
+      body.rels ?? "\0",
+      resolved.xml,
+      ...connectSignature(connects)
+    ]);
     pages.push({
       key: page.key,
       id: finalId,
       ...page.entry.back !== void 0 ? { back: page.entry.back } : {},
       xml,
-      body: page.body,
-      shapes,
-      connects
+      body,
+      shapes: resolved.shapes,
+      shapesXml: resolved.xml,
+      connects,
+      signature: hashTexts([xml, contentSignature]),
+      contentSignature
     });
   }
+  const mastersDir = mastersPath !== void 0 ? dirName(mastersPath) : pagesDir;
+  const finalMasters = masters.map((m) => {
+    const batch = shared.masters.get(m.key)?.b;
+    const rename = typeof batch === "string" ? renames.get(batch) : void 0;
+    const scope = masterScope(m.key);
+    const resolved = resolveShapes({
+      scope,
+      shapes: shapesByPage.get(scope) ?? /* @__PURE__ */ new Map(),
+      cells: cellsByPage.get(scope) ?? /* @__PURE__ */ new Map(),
+      renum: renumByScope.get(scope) ?? /* @__PURE__ */ new Map(),
+      masterRemap: /* @__PURE__ */ new Map()
+    });
+    fixups.push(...resolved.fixups);
+    return {
+      ...m,
+      ...rename && m.rels !== void 0 ? { rels: renameTargets(m.rels, mastersDir, rename) } : {},
+      shapes: resolved.shapes,
+      shapesXml: resolved.xml,
+      connects: resolveConnects(connectsByPage.get(scope), resolved.shapes)
+    };
+  });
   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 };
+  const baseSignature = hashTexts([
+    pagesPath,
+    pagesOpen,
+    pagesClose,
+    mastersPath ?? "",
+    mastersOpen ?? "",
+    mastersClose ?? "",
+    ...pages.map((p) => `${p.key}:${p.id}:${p.xml}`),
+    ...finalMasters.flatMap((m) => [
+      m.key,
+      m.id,
+      m.xml,
+      m.part,
+      m.rels ?? "\0",
+      m.shapesXml,
+      ...connectSignature(m.connects)
+    ]),
+    ...media.flatMap((m) => [m.path, m.hash, m.declared.type, String(m.declared.byDefault)]),
+    ...[...parts].flatMap(([path, data]) => [path, data])
+  ]);
+  const signature = hashTexts([
+    baseSignature,
+    ...pages.map((p) => `${p.key}:${p.contentSignature}`)
+  ]);
+  return {
+    pagesPath,
+    pagesOpen,
+    pagesClose,
+    pages,
+    ...mastersPath !== void 0 && mastersOpen !== void 0 && mastersClose !== void 0 ? { mastersPath, mastersOpen, mastersClose } : {},
+    masters: finalMasters,
+    media,
+    parts,
+    signature,
+    baseSignature,
+    fixups
+  };
 }
-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));
+
+// visio/collab/write-shapes.ts
+function syncEntry(ctx, map, mapKey, id, content, room, roomContent, local, stamp = false) {
+  ctx.now.set(id, content);
+  const base = ctx.keys.known.get(id);
+  const own = base === void 0 ? !room || roomContent() !== content : base !== content;
+  if (own || !room) {
+    const value = local();
+    ctx.write(map, mapKey, stamp ? { ...value, b: ctx.batch } : value);
+  } else {
+    const pos = local().pos;
+    ctx.write(map, mapKey, pos === void 0 ? room : { ...room, pos });
+  }
+}
+function groupPositions(items, current) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) groups.set(item.group, [...groups.get(item.group) ?? [], item.key]);
+  const out = /* @__PURE__ */ new Map();
+  for (const list of groups.values())
+    for (const [key, pos] of assignPositions(list, current)) out.set(key, pos);
+  return out;
+}
+function syncConnects(ctx, connects) {
+  for (const connect of connects) {
+    ctx.now.set(connectId(connect.key), "");
+    if (!ctx.keys.known.has(connectId(connect.key)) || !ctx.shared.connects.has(connect.key))
+      ctx.write(ctx.shared.connects, connect.key, connect.entry);
+  }
+}
+function syncShapes(ctx, page) {
+  const { shared } = ctx;
+  const shapePos = groupPositions(
+    page.shapes.map((s) => ({ key: s.key, group: s.parent ?? "" })),
+    (key) => shapeEntry(shared.shapes.get(`${page.key}/${key}`))?.pos
+  );
+  for (const shape of page.shapes) {
+    const full = `${page.key}/${shape.key}`;
+    const room = shapeEntry(shared.shapes.get(full));
+    const parent = shape.parent;
+    syncEntry(
+      ctx,
+      shared.shapes,
+      full,
+      shapeId(page.key, shape.key),
+      shellContent({ parent, open: shape.open }),
+      room,
+      () => shellContent(room),
+      () => ({
+        pos: shapePos.get(shape.key),
+        ...parent !== void 0 ? { parent } : {},
+        open: shape.open,
+        b: room?.b ?? ctx.batch
+      })
+    );
+    const piecePos = groupPositions(
+      shape.pieces.map((p) => ({ key: p.path, group: p.parent })),
+      (path) => cellEntry(shared.cells.get(`${full}/${path}`))?.pos
+    );
+    for (const piece of shape.pieces) {
+      const cellKey = `${full}/${piece.path}`;
+      const roomCell = cellEntry(shared.cells.get(cellKey));
+      const local = () => ({
+        pos: piecePos.get(piece.path),
+        ...piece.kind === "leaf" ? { xml: piece.text } : { open: piece.text }
+      });
+      syncEntry(
+        ctx,
+        shared.cells,
+        cellKey,
+        cellId(page.key, shape.key, piece.path),
+        entryContent(piece.kind === "leaf" ? { xml: piece.text } : { open: piece.text }),
+        roomCell,
+        () => entryContent(roomCell),
+        local
+      );
     }
-    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/write-parts.ts
+var mediaKey = (hash, path) => `${hash}|${path}`;
+function syncMasters(ctx, snapshot) {
+  const { shared } = ctx;
+  const pos = assignPositions(
+    snapshot.masters.map((m) => m.key),
+    (key) => masterEntry(shared.masters.get(key))?.pos
+  );
+  for (const master of snapshot.masters) {
+    const room = masterEntry(shared.masters.get(master.key));
+    syncEntry(
+      ctx,
+      shared.masters,
+      master.key,
+      masterId(master.key),
+      masterContent({ ...master, print: fingerprint(master.part) }),
+      room,
+      () => masterContent({
+        ...room,
+        print: fingerprint(fromBase64(room.part))
+      }),
+      () => ({
+        pos: pos.get(master.key),
+        id: master.id,
+        xml: master.xml,
+        part: toBase64(master.part),
+        ...master.rels !== void 0 ? { rels: master.rels } : {}
+      }),
+      true
+    );
+    syncShapes(ctx, { key: masterScope(master.key), shapes: master.shapes });
+    syncConnects(ctx, master.connects);
+  }
+}
+function syncMedia(ctx, snapshot) {
+  const { shared } = ctx;
+  for (const item of snapshot.media) {
+    const known = ctx.keys.mediaKeys.get(item.path);
+    const key = known?.startsWith(`${item.hash}|`) ? known : mediaKey(item.hash, item.path);
+    ctx.now.set(mediaId(key), "");
+    if (!mediaEntry(shared.media.get(key))) {
+      ctx.write(shared.media, key, {
+        path: item.path,
+        hash: item.hash,
+        ct: item.ct,
+        d: item.d,
+        b: ctx.batch
+      });
+      shared.blobs.set(item.hash, toBase64(item.data));
+    } else if (!shared.blobs.has(item.hash)) shared.blobs.set(item.hash, toBase64(item.data));
+  }
+}
+function syncParts(ctx, snapshot) {
+  const { shared, keys } = ctx;
+  for (const [path, data] of snapshot.parts) {
+    const print = fingerprint(data);
+    if (keys.partPrints.get(path) === print) continue;
+    ctx.write(shared.parts, path, toBase64(data));
+    keys.partPrints.set(path, print);
+  }
+  let removed = 0;
+  for (const path of [...keys.partPrints.keys()])
+    if (!snapshot.parts.has(path)) {
+      shared.parts.delete(path);
+      keys.partPrints.delete(path);
+      removed++;
+    }
+  return removed;
+}
+
+// visio/collab/write.ts
+function removeScope(shared, name) {
+  shared.renum.delete(name);
+  for (const map of [shared.shapes, shared.cells, shared.connects, shared.renum])
+    for (const key of [...map.keys()]) if (key.startsWith(`${name}/`)) map.delete(key);
+}
+function removePage(shared, name) {
+  shared.dead.set(name, true);
+  for (const map of [shared.pages, shared.bodies]) map.delete(name);
+  removeScope(shared, name);
+}
+function writeSharedDrawing(shared, snapshot, keys) {
+  assertSchemaVersion(shared);
+  let writes = 0;
+  const write = (map, key, value) => {
+    if (setIfChanged(map, key, value)) writes++;
+  };
+  const now = /* @__PURE__ */ new Map();
+  const ctx = { shared, keys, now, batch: keys.batch(), write };
+  write(shared.meta, "v", SCHEMA_VERSION);
+  write(shared.meta, "pagesPath", snapshot.pagesPath);
+  write(shared.meta, "pagesOpen", snapshot.pagesOpen);
+  write(shared.meta, "pagesClose", snapshot.pagesClose);
+  if (snapshot.mastersPath !== void 0) {
+    write(shared.meta, "mastersPath", snapshot.mastersPath);
+    write(shared.meta, "mastersOpen", snapshot.mastersOpen);
+    write(shared.meta, "mastersClose", snapshot.mastersClose);
+  }
+  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));
+    syncEntry(
+      ctx,
+      shared.pages,
+      page.key,
+      pageId(page.key),
+      pageContent(page),
+      room,
+      () => pageContent(room),
+      () => ({
+        pos: pagePos.get(page.key),
+        id: page.id,
+        ...page.back !== void 0 ? { back: page.back } : {},
+        xml: page.xml
+      })
+    );
+    const roomBody = bodyEntry(shared.bodies.get(page.key));
+    syncEntry(
+      ctx,
+      shared.bodies,
+      page.key,
+      bodyId(page.key),
+      bodyContent(page),
+      roomBody,
+      () => bodyContent(roomBody),
+      () => ({ shell: page.shell, ...page.rels !== void 0 ? { rels: page.rels } : {} }),
+      true
+    );
+    syncShapes(ctx, page);
+    syncConnects(ctx, page.connects);
+  }
+  syncMasters(ctx, snapshot);
+  syncMedia(ctx, snapshot);
+  for (const id of keys.known.keys()) {
+    if (now.has(id)) continue;
+    const name = id.slice(2);
+    switch (id.slice(0, 2)) {
+      case "p:":
+        removePage(shared, name);
+        keys.forgetPage(name);
+        writes++;
+        break;
+      case "s:": {
+        const slash = name.indexOf("/");
+        const page = name.slice(0, slash);
+        if (!now.has(page.startsWith(masterScope("")) ? masterId(page.slice(2)) : pageId(page)))
+          break;
+        shared.dead.set(name, true);
+        shared.shapes.delete(name);
+        keys.forgetShape(page, name.slice(slash + 1));
+        writes++;
+        break;
+      }
+      case "f:":
+        if (shared.cells.has(name)) {
+          shared.cells.delete(name);
+          writes++;
+        }
+        break;
+      case "c:":
+        if (shared.connects.has(name)) {
+          shared.connects.delete(name);
+          writes++;
+        }
+        break;
+      case "m:":
+        if (shared.masters.has(name)) {
+          shared.masters.delete(name);
+          removeScope(shared, masterScope(name));
+          writes++;
+        }
+        keys.forgetMaster(name);
+        break;
+      case "i:":
+        if (shared.media.has(name)) {
+          shared.media.delete(name);
+          writes++;
+        }
+        break;
+    }
+  }
+  keys.known = now;
+  writes += syncParts(ctx, snapshot);
+  return writes;
 }
 
 // visio/collab/bind.ts
 var VISIO_EDIT_ORIGIN = /* @__PURE__ */ Symbol("ooxml-core:visio:edit");
 var VISIO_SYNC_ORIGIN = /* @__PURE__ */ Symbol("ooxml-core:visio:sync");
+var VISIO_FIXUP_ORIGIN = /* @__PURE__ */ Symbol("ooxml-core:visio:fixup");
 function bindDrawingSession(host, editor, options = {}) {
   const { doc } = host;
   const shared = sharedDrawing(doc);
@@ -1040,6 +2134,12 @@ function bindDrawingSession(host, editor, options = {}) {
   let settled = false;
   let localDirty = false;
   let remoteDirty = false;
+  let incompatible = false;
+  let queued = false;
+  let queuedDone;
+  const schedule = options.schedule ?? ((run) => {
+    setTimeout(run, 0);
+  });
   let running;
   const report = (error) => options.onError?.(error);
   const publish = async () => {
@@ -1058,7 +2158,14 @@ function bindDrawingSession(host, editor, options = {}) {
   const rebuild = async () => {
     const resolved = readSharedDrawing(shared);
     if (!resolved) return;
+    if (resolved.fixups.length && host.canWrite())
+      doc.transact(() => applyFixups(shared, resolved.fixups), VISIO_FIXUP_ORIGIN);
     const version = editor.version();
+    if (keys.applied?.signature === resolved.signature && keys.applied.version === version) return;
+    const before = keys.applied;
+    const change = before && before.version === version && before.base === resolved.baseSignature ? {
+      pages: resolved.pages.filter((page) => before.pages.get(page.key) !== page.contentSignature).map((page) => page.id)
+    } : void 0;
     const composed = await composeDrawing(resolved, editor.exportBytes(), keys);
     if (disposed) return;
     if (editor.busy() || editor.version() !== version) {
@@ -1066,15 +2173,21 @@ function bindDrawingSession(host, editor, options = {}) {
       return;
     }
     try {
-      await editor.applyRemote(composed.bytes);
+      await editor.applyRemote(composed.bytes, change);
     } catch (error) {
       if (editor.busy()) remoteDirty = true;
       else report(error);
       return;
     }
     composed.commit();
+    keys.applied = {
+      signature: composed.signature,
+      version: editor.version(),
+      base: resolved.baseSignature,
+      pages: new Map(resolved.pages.map((page) => [page.key, page.contentSignature]))
+    };
   };
-  const blocked = () => disposed || !settled || editor.busy();
+  const blocked = () => disposed || incompatible || !settled || editor.busy();
   const pending = () => !blocked() && (localDirty && host.canWrite() || remoteDirty && !localDirty);
   const loop = async () => {
     while (pending()) {
@@ -1087,6 +2200,7 @@ function bindDrawingSession(host, editor, options = {}) {
           await rebuild();
         }
       } catch (error) {
+        if (error instanceof SchemaVersionError) incompatible = true;
         report(error);
       }
     }
@@ -1113,18 +2227,30 @@ function bindDrawingSession(host, editor, options = {}) {
     }
     pump();
   };
+  const queueRemote = () => {
+    if (queued) return;
+    queued = true;
+    queuedDone = new Promise(
+      (resolve) => schedule(() => {
+        queued = false;
+        remoteDirty = true;
+        resolve();
+        pump();
+      })
+    );
+  };
   const afterTransaction = (transaction) => {
     if (disposed) return;
     const origin = transaction.origin;
-    if (origin === VISIO_EDIT_ORIGIN || origin === VISIO_SYNC_ORIGIN) return;
+    if (origin === VISIO_EDIT_ORIGIN || origin === VISIO_SYNC_ORIGIN || origin === VISIO_FIXUP_ORIGIN)
+      return;
     const changed = transaction.changed;
     if (!types.some((type) => changed.has(type))) return;
     if (!settled) {
       if (!isSharedDrawingEmpty(shared)) settle();
       return;
     }
-    remoteDirty = true;
-    pump();
+    queueRemote();
   };
   doc.on("afterTransaction", afterTransaction);
   const stops = [
@@ -1142,7 +2268,10 @@ function bindDrawingSession(host, editor, options = {}) {
   ];
   if (host.synced || host.canWrite()) settle();
   const idle = async () => {
-    while (running) await running;
+    while (running || queued) {
+      if (queued) await queuedDone;
+      if (running) await running;
+    }
   };
   const replay = async (kind) => {
     await idle();
@@ -1174,17 +2303,25 @@ function bindDrawingSession(host, editor, options = {}) {
   };
 }
 
+exports.BLOBS = BLOBS;
 exports.BODIES = BODIES;
+exports.CELLS = CELLS;
 exports.CONNECTS = CONNECTS;
 exports.DEAD = DEAD;
 exports.DrawingKeys = DrawingKeys;
+exports.MASTERS = MASTERS;
+exports.MEDIA = MEDIA;
 exports.META = META;
 exports.PAGES = PAGES;
 exports.PARTS = PARTS;
+exports.RENUM = RENUM;
 exports.SCHEMA_VERSION = SCHEMA_VERSION;
 exports.SHAPES = SHAPES;
+exports.SchemaVersionError = SchemaVersionError;
 exports.VISIO_EDIT_ORIGIN = VISIO_EDIT_ORIGIN;
+exports.VISIO_FIXUP_ORIGIN = VISIO_FIXUP_ORIGIN;
 exports.VISIO_SYNC_ORIGIN = VISIO_SYNC_ORIGIN;
+exports.applyFixups = applyFixups;
 exports.bindDrawingSession = bindDrawingSession;
 exports.composeDrawing = composeDrawing;
 exports.isSharedDrawingEmpty = isSharedDrawingEmpty;